337 files changed, 94610 insertions, 0 deletions

diff --git a/vendor/github.com/dustin/go-humanize/.travis.yml b/vendor/github.com/dustin/go-humanize/.travis.yml
new file mode 100644
index 0000000..ac12e48
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/.travis.yml
@@ -0,0 +1,21 @@
+sudo: false
+language: go
+go_import_path: github.com/dustin/go-humanize
+go:
+  - 1.13.x
+  - 1.14.x
+  - 1.15.x
+  - 1.16.x
+  - stable
+  - master
+matrix:
+  allow_failures:
+    - go: master
+  fast_finish: true
+install:
+  - # Do nothing. This is needed to prevent default install action "go get -t -v ./..." from happening here (we want it to happen inside script step).
+script:
+  - diff -u <(echo -n) <(gofmt -d -s .)
+  - go vet .
+  - go install -v -race ./...
+  - go test -v -race ./...
diff --git a/vendor/github.com/dustin/go-humanize/LICENSE b/vendor/github.com/dustin/go-humanize/LICENSE
new file mode 100644
index 0000000..8d9a94a
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/LICENSE
@@ -0,0 +1,21 @@
+Copyright (c) 2005-2008  Dustin Sallings <[email protected]>
+
+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.
+
+<http://www.opensource.org/licenses/mit-license.php>
diff --git a/vendor/github.com/dustin/go-humanize/README.markdown b/vendor/github.com/dustin/go-humanize/README.markdown
new file mode 100644
index 0000000..7d0b16b
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/README.markdown
@@ -0,0 +1,124 @@
+# Humane Units [![Build Status](https://travis-ci.org/dustin/go-humanize.svg?branch=master)](https://travis-ci.org/dustin/go-humanize) [![GoDoc](https://godoc.org/github.com/dustin/go-humanize?status.svg)](https://godoc.org/github.com/dustin/go-humanize)
+
+Just a few functions for helping humanize times and sizes.
+
+`go get` it as `github.com/dustin/go-humanize`, import it as
+`"github.com/dustin/go-humanize"`, use it as `humanize`.
+
+See [godoc](https://pkg.go.dev/github.com/dustin/go-humanize) for
+complete documentation.
+
+## Sizes
+
+This lets you take numbers like `82854982` and convert them to useful
+strings like, `83 MB` or `79 MiB` (whichever you prefer).
+
+Example:
+
+```go
+fmt.Printf("That file is %s.", humanize.Bytes(82854982)) // That file is 83 MB.
+```
+
+## Times
+
+This lets you take a `time.Time` and spit it out in relative terms.
+For example, `12 seconds ago` or `3 days from now`.
+
+Example:
+
+```go
+fmt.Printf("This was touched %s.", humanize.Time(someTimeInstance)) // This was touched 7 hours ago.
+```
+
+Thanks to Kyle Lemons for the time implementation from an IRC
+conversation one day. It's pretty neat.
+
+## Ordinals
+
+From a [mailing list discussion][odisc] where a user wanted to be able
+to label ordinals.
+
+    0 -> 0th
+    1 -> 1st
+    2 -> 2nd
+    3 -> 3rd
+    4 -> 4th
+    [...]
+
+Example:
+
+```go
+fmt.Printf("You're my %s best friend.", humanize.Ordinal(193)) // You are my 193rd best friend.
+```
+
+## Commas
+
+Want to shove commas into numbers? Be my guest.
+
+    0 -> 0
+    100 -> 100
+    1000 -> 1,000
+    1000000000 -> 1,000,000,000
+    -100000 -> -100,000
+
+Example:
+
+```go
+fmt.Printf("You owe $%s.\n", humanize.Comma(6582491)) // You owe $6,582,491.
+```
+
+## Ftoa
+
+Nicer float64 formatter that removes trailing zeros.
+
+```go
+fmt.Printf("%f", 2.24)                // 2.240000
+fmt.Printf("%s", humanize.Ftoa(2.24)) // 2.24
+fmt.Printf("%f", 2.0)                 // 2.000000
+fmt.Printf("%s", humanize.Ftoa(2.0))  // 2
+```
+
+## SI notation
+
+Format numbers with [SI notation][sinotation].
+
+Example:
+
+```go
+humanize.SI(0.00000000223, "M") // 2.23 nM
+```
+
+## English-specific functions
+
+The following functions are in the `humanize/english` subpackage.
+
+### Plurals
+
+Simple English pluralization
+
+```go
+english.PluralWord(1, "object", "") // object
+english.PluralWord(42, "object", "") // objects
+english.PluralWord(2, "bus", "") // buses
+english.PluralWord(99, "locus", "loci") // loci
+
+english.Plural(1, "object", "") // 1 object
+english.Plural(42, "object", "") // 42 objects
+english.Plural(2, "bus", "") // 2 buses
+english.Plural(99, "locus", "loci") // 99 loci
+```
+
+### Word series
+
+Format comma-separated words lists with conjuctions:
+
+```go
+english.WordSeries([]string{"foo"}, "and") // foo
+english.WordSeries([]string{"foo", "bar"}, "and") // foo and bar
+english.WordSeries([]string{"foo", "bar", "baz"}, "and") // foo, bar and baz
+
+english.OxfordWordSeries([]string{"foo", "bar", "baz"}, "and") // foo, bar, and baz
+```
+
+[odisc]: https://groups.google.com/d/topic/golang-nuts/l8NhI74jl-4/discussion
+[sinotation]: http://en.wikipedia.org/wiki/Metric_prefix
diff --git a/vendor/github.com/dustin/go-humanize/big.go b/vendor/github.com/dustin/go-humanize/big.go
new file mode 100644
index 0000000..f49dc33
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/big.go
@@ -0,0 +1,31 @@
+package humanize
+
+import (
+        "math/big"
+)
+
+// order of magnitude (to a max order)
+func oomm(n, b *big.Int, maxmag int) (float64, int) {
+        mag := 0
+        m := &big.Int{}
+        for n.Cmp(b) >= 0 {
+                n.DivMod(n, b, m)
+                mag++
+                if mag == maxmag && maxmag >= 0 {
+                        break
+                }
+        }
+        return float64(n.Int64()) + (float64(m.Int64()) / float64(b.Int64())), mag
+}
+
+// total order of magnitude
+// (same as above, but with no upper limit)
+func oom(n, b *big.Int) (float64, int) {
+        mag := 0
+        m := &big.Int{}
+        for n.Cmp(b) >= 0 {
+                n.DivMod(n, b, m)
+                mag++
+        }
+        return float64(n.Int64()) + (float64(m.Int64()) / float64(b.Int64())), mag
+}
diff --git a/vendor/github.com/dustin/go-humanize/bigbytes.go b/vendor/github.com/dustin/go-humanize/bigbytes.go
new file mode 100644
index 0000000..3b015fd
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/bigbytes.go
@@ -0,0 +1,189 @@
+package humanize
+
+import (
+        "fmt"
+        "math/big"
+        "strings"
+        "unicode"
+)
+
+var (
+        bigIECExp = big.NewInt(1024)
+
+        // BigByte is one byte in bit.Ints
+        BigByte = big.NewInt(1)
+        // BigKiByte is 1,024 bytes in bit.Ints
+        BigKiByte = (&big.Int{}).Mul(BigByte, bigIECExp)
+        // BigMiByte is 1,024 k bytes in bit.Ints
+        BigMiByte = (&big.Int{}).Mul(BigKiByte, bigIECExp)
+        // BigGiByte is 1,024 m bytes in bit.Ints
+        BigGiByte = (&big.Int{}).Mul(BigMiByte, bigIECExp)
+        // BigTiByte is 1,024 g bytes in bit.Ints
+        BigTiByte = (&big.Int{}).Mul(BigGiByte, bigIECExp)
+        // BigPiByte is 1,024 t bytes in bit.Ints
+        BigPiByte = (&big.Int{}).Mul(BigTiByte, bigIECExp)
+        // BigEiByte is 1,024 p bytes in bit.Ints
+        BigEiByte = (&big.Int{}).Mul(BigPiByte, bigIECExp)
+        // BigZiByte is 1,024 e bytes in bit.Ints
+        BigZiByte = (&big.Int{}).Mul(BigEiByte, bigIECExp)
+        // BigYiByte is 1,024 z bytes in bit.Ints
+        BigYiByte = (&big.Int{}).Mul(BigZiByte, bigIECExp)
+        // BigRiByte is 1,024 y bytes in bit.Ints
+        BigRiByte = (&big.Int{}).Mul(BigYiByte, bigIECExp)
+        // BigQiByte is 1,024 r bytes in bit.Ints
+        BigQiByte = (&big.Int{}).Mul(BigRiByte, bigIECExp)
+)
+
+var (
+        bigSIExp = big.NewInt(1000)
+
+        // BigSIByte is one SI byte in big.Ints
+        BigSIByte = big.NewInt(1)
+        // BigKByte is 1,000 SI bytes in big.Ints
+        BigKByte = (&big.Int{}).Mul(BigSIByte, bigSIExp)
+        // BigMByte is 1,000 SI k bytes in big.Ints
+        BigMByte = (&big.Int{}).Mul(BigKByte, bigSIExp)
+        // BigGByte is 1,000 SI m bytes in big.Ints
+        BigGByte = (&big.Int{}).Mul(BigMByte, bigSIExp)
+        // BigTByte is 1,000 SI g bytes in big.Ints
+        BigTByte = (&big.Int{}).Mul(BigGByte, bigSIExp)
+        // BigPByte is 1,000 SI t bytes in big.Ints
+        BigPByte = (&big.Int{}).Mul(BigTByte, bigSIExp)
+        // BigEByte is 1,000 SI p bytes in big.Ints
+        BigEByte = (&big.Int{}).Mul(BigPByte, bigSIExp)
+        // BigZByte is 1,000 SI e bytes in big.Ints
+        BigZByte = (&big.Int{}).Mul(BigEByte, bigSIExp)
+        // BigYByte is 1,000 SI z bytes in big.Ints
+        BigYByte = (&big.Int{}).Mul(BigZByte, bigSIExp)
+        // BigRByte is 1,000 SI y bytes in big.Ints
+        BigRByte = (&big.Int{}).Mul(BigYByte, bigSIExp)
+        // BigQByte is 1,000 SI r bytes in big.Ints
+        BigQByte = (&big.Int{}).Mul(BigRByte, bigSIExp)
+)
+
+var bigBytesSizeTable = map[string]*big.Int{
+        "b":   BigByte,
+        "kib": BigKiByte,
+        "kb":  BigKByte,
+        "mib": BigMiByte,
+        "mb":  BigMByte,
+        "gib": BigGiByte,
+        "gb":  BigGByte,
+        "tib": BigTiByte,
+        "tb":  BigTByte,
+        "pib": BigPiByte,
+        "pb":  BigPByte,
+        "eib": BigEiByte,
+        "eb":  BigEByte,
+        "zib": BigZiByte,
+        "zb":  BigZByte,
+        "yib": BigYiByte,
+        "yb":  BigYByte,
+        "rib": BigRiByte,
+        "rb":  BigRByte,
+        "qib": BigQiByte,
+        "qb":  BigQByte,
+        // Without suffix
+        "":   BigByte,
+        "ki": BigKiByte,
+        "k":  BigKByte,
+        "mi": BigMiByte,
+        "m":  BigMByte,
+        "gi": BigGiByte,
+        "g":  BigGByte,
+        "ti": BigTiByte,
+        "t":  BigTByte,
+        "pi": BigPiByte,
+        "p":  BigPByte,
+        "ei": BigEiByte,
+        "e":  BigEByte,
+        "z":  BigZByte,
+        "zi": BigZiByte,
+        "y":  BigYByte,
+        "yi": BigYiByte,
+        "r":  BigRByte,
+        "ri": BigRiByte,
+        "q":  BigQByte,
+        "qi": BigQiByte,
+}
+
+var ten = big.NewInt(10)
+
+func humanateBigBytes(s, base *big.Int, sizes []string) string {
+        if s.Cmp(ten) < 0 {
+                return fmt.Sprintf("%d B", s)
+        }
+        c := (&big.Int{}).Set(s)
+        val, mag := oomm(c, base, len(sizes)-1)
+        suffix := sizes[mag]
+        f := "%.0f %s"
+        if val < 10 {
+                f = "%.1f %s"
+        }
+
+        return fmt.Sprintf(f, val, suffix)
+
+}
+
+// BigBytes produces a human readable representation of an SI size.
+//
+// See also: ParseBigBytes.
+//
+// BigBytes(82854982) -> 83 MB
+func BigBytes(s *big.Int) string {
+        sizes := []string{"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB", "RB", "QB"}
+        return humanateBigBytes(s, bigSIExp, sizes)
+}
+
+// BigIBytes produces a human readable representation of an IEC size.
+//
+// See also: ParseBigBytes.
+//
+// BigIBytes(82854982) -> 79 MiB
+func BigIBytes(s *big.Int) string {
+        sizes := []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB", "RiB", "QiB"}
+        return humanateBigBytes(s, bigIECExp, sizes)
+}
+
+// ParseBigBytes parses a string representation of bytes into the number
+// of bytes it represents.
+//
+// See also: BigBytes, BigIBytes.
+//
+// ParseBigBytes("42 MB") -> 42000000, nil
+// ParseBigBytes("42 mib") -> 44040192, nil
+func ParseBigBytes(s string) (*big.Int, error) {
+        lastDigit := 0
+        hasComma := false
+        for _, r := range s {
+                if !(unicode.IsDigit(r) || r == '.' || r == ',') {
+                        break
+                }
+                if r == ',' {
+                        hasComma = true
+                }
+                lastDigit++
+        }
+
+        num := s[:lastDigit]
+        if hasComma {
+                num = strings.Replace(num, ",", "", -1)
+        }
+
+        val := &big.Rat{}
+        _, err := fmt.Sscanf(num, "%f", val)
+        if err != nil {
+                return nil, err
+        }
+
+        extra := strings.ToLower(strings.TrimSpace(s[lastDigit:]))
+        if m, ok := bigBytesSizeTable[extra]; ok {
+                mv := (&big.Rat{}).SetInt(m)
+                val.Mul(val, mv)
+                rv := &big.Int{}
+                rv.Div(val.Num(), val.Denom())
+                return rv, nil
+        }
+
+        return nil, fmt.Errorf("unhandled size name: %v", extra)
+}
diff --git a/vendor/github.com/dustin/go-humanize/bytes.go b/vendor/github.com/dustin/go-humanize/bytes.go
new file mode 100644
index 0000000..0b498f4
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/bytes.go
@@ -0,0 +1,143 @@
+package humanize
+
+import (
+        "fmt"
+        "math"
+        "strconv"
+        "strings"
+        "unicode"
+)
+
+// IEC Sizes.
+// kibis of bits
+const (
+        Byte = 1 << (iota * 10)
+        KiByte
+        MiByte
+        GiByte
+        TiByte
+        PiByte
+        EiByte
+)
+
+// SI Sizes.
+const (
+        IByte = 1
+        KByte = IByte * 1000
+        MByte = KByte * 1000
+        GByte = MByte * 1000
+        TByte = GByte * 1000
+        PByte = TByte * 1000
+        EByte = PByte * 1000
+)
+
+var bytesSizeTable = map[string]uint64{
+        "b":   Byte,
+        "kib": KiByte,
+        "kb":  KByte,
+        "mib": MiByte,
+        "mb":  MByte,
+        "gib": GiByte,
+        "gb":  GByte,
+        "tib": TiByte,
+        "tb":  TByte,
+        "pib": PiByte,
+        "pb":  PByte,
+        "eib": EiByte,
+        "eb":  EByte,
+        // Without suffix
+        "":   Byte,
+        "ki": KiByte,
+        "k":  KByte,
+        "mi": MiByte,
+        "m":  MByte,
+        "gi": GiByte,
+        "g":  GByte,
+        "ti": TiByte,
+        "t":  TByte,
+        "pi": PiByte,
+        "p":  PByte,
+        "ei": EiByte,
+        "e":  EByte,
+}
+
+func logn(n, b float64) float64 {
+        return math.Log(n) / math.Log(b)
+}
+
+func humanateBytes(s uint64, base float64, sizes []string) string {
+        if s < 10 {
+                return fmt.Sprintf("%d B", s)
+        }
+        e := math.Floor(logn(float64(s), base))
+        suffix := sizes[int(e)]
+        val := math.Floor(float64(s)/math.Pow(base, e)*10+0.5) / 10
+        f := "%.0f %s"
+        if val < 10 {
+                f = "%.1f %s"
+        }
+
+        return fmt.Sprintf(f, val, suffix)
+}
+
+// Bytes produces a human readable representation of an SI size.
+//
+// See also: ParseBytes.
+//
+// Bytes(82854982) -> 83 MB
+func Bytes(s uint64) string {
+        sizes := []string{"B", "kB", "MB", "GB", "TB", "PB", "EB"}
+        return humanateBytes(s, 1000, sizes)
+}
+
+// IBytes produces a human readable representation of an IEC size.
+//
+// See also: ParseBytes.
+//
+// IBytes(82854982) -> 79 MiB
+func IBytes(s uint64) string {
+        sizes := []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"}
+        return humanateBytes(s, 1024, sizes)
+}
+
+// ParseBytes parses a string representation of bytes into the number
+// of bytes it represents.
+//
+// See Also: Bytes, IBytes.
+//
+// ParseBytes("42 MB") -> 42000000, nil
+// ParseBytes("42 mib") -> 44040192, nil
+func ParseBytes(s string) (uint64, error) {
+        lastDigit := 0
+        hasComma := false
+        for _, r := range s {
+                if !(unicode.IsDigit(r) || r == '.' || r == ',') {
+                        break
+                }
+                if r == ',' {
+                        hasComma = true
+                }
+                lastDigit++
+        }
+
+        num := s[:lastDigit]
+        if hasComma {
+                num = strings.Replace(num, ",", "", -1)
+        }
+
+        f, err := strconv.ParseFloat(num, 64)
+        if err != nil {
+                return 0, err
+        }
+
+        extra := strings.ToLower(strings.TrimSpace(s[lastDigit:]))
+        if m, ok := bytesSizeTable[extra]; ok {
+                f *= float64(m)
+                if f >= math.MaxUint64 {
+                        return 0, fmt.Errorf("too large: %v", s)
+                }
+                return uint64(f), nil
+        }
+
+        return 0, fmt.Errorf("unhandled size name: %v", extra)
+}
diff --git a/vendor/github.com/dustin/go-humanize/comma.go b/vendor/github.com/dustin/go-humanize/comma.go
new file mode 100644
index 0000000..520ae3e
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/comma.go
@@ -0,0 +1,116 @@
+package humanize
+
+import (
+        "bytes"
+        "math"
+        "math/big"
+        "strconv"
+        "strings"
+)
+
+// Comma produces a string form of the given number in base 10 with
+// commas after every three orders of magnitude.
+//
+// e.g. Comma(834142) -> 834,142
+func Comma(v int64) string {
+        sign := ""
+
+        // Min int64 can't be negated to a usable value, so it has to be special cased.
+        if v == math.MinInt64 {
+                return "-9,223,372,036,854,775,808"
+        }
+
+        if v < 0 {
+                sign = "-"
+                v = 0 - v
+        }
+
+        parts := []string{"", "", "", "", "", "", ""}
+        j := len(parts) - 1
+
+        for v > 999 {
+                parts[j] = strconv.FormatInt(v%1000, 10)
+                switch len(parts[j]) {
+                case 2:
+                        parts[j] = "0" + parts[j]
+                case 1:
+                        parts[j] = "00" + parts[j]
+                }
+                v = v / 1000
+                j--
+        }
+        parts[j] = strconv.Itoa(int(v))
+        return sign + strings.Join(parts[j:], ",")
+}
+
+// Commaf produces a string form of the given number in base 10 with
+// commas after every three orders of magnitude.
+//
+// e.g. Commaf(834142.32) -> 834,142.32
+func Commaf(v float64) string {
+        buf := &bytes.Buffer{}
+        if v < 0 {
+                buf.Write([]byte{'-'})
+                v = 0 - v
+        }
+
+        comma := []byte{','}
+
+        parts := strings.Split(strconv.FormatFloat(v, 'f', -1, 64), ".")
+        pos := 0
+        if len(parts[0])%3 != 0 {
+                pos += len(parts[0]) % 3
+                buf.WriteString(parts[0][:pos])
+                buf.Write(comma)
+        }
+        for ; pos < len(parts[0]); pos += 3 {
+                buf.WriteString(parts[0][pos : pos+3])
+                buf.Write(comma)
+        }
+        buf.Truncate(buf.Len() - 1)
+
+        if len(parts) > 1 {
+                buf.Write([]byte{'.'})
+                buf.WriteString(parts[1])
+        }
+        return buf.String()
+}
+
+// CommafWithDigits works like the Commaf but limits the resulting
+// string to the given number of decimal places.
+//
+// e.g. CommafWithDigits(834142.32, 1) -> 834,142.3
+func CommafWithDigits(f float64, decimals int) string {
+        return stripTrailingDigits(Commaf(f), decimals)
+}
+
+// BigComma produces a string form of the given big.Int in base 10
+// with commas after every three orders of magnitude.
+func BigComma(b *big.Int) string {
+        sign := ""
+        if b.Sign() < 0 {
+                sign = "-"
+                b.Abs(b)
+        }
+
+        athousand := big.NewInt(1000)
+        c := (&big.Int{}).Set(b)
+        _, m := oom(c, athousand)
+        parts := make([]string, m+1)
+        j := len(parts) - 1
+
+        mod := &big.Int{}
+        for b.Cmp(athousand) >= 0 {
+                b.DivMod(b, athousand, mod)
+                parts[j] = strconv.FormatInt(mod.Int64(), 10)
+                switch len(parts[j]) {
+                case 2:
+                        parts[j] = "0" + parts[j]
+                case 1:
+                        parts[j] = "00" + parts[j]
+                }
+                j--
+        }
+        parts[j] = strconv.Itoa(int(b.Int64()))
+        return sign + strings.Join(parts[j:], ",")
+}
diff --git a/vendor/github.com/dustin/go-humanize/commaf.go b/vendor/github.com/dustin/go-humanize/commaf.go
new file mode 100644
index 0000000..2bc83a0
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/commaf.go
@@ -0,0 +1,41 @@
+//go:build go1.6
+// +build go1.6
+
+package humanize
+
+import (
+        "bytes"
+        "math/big"
+        "strings"
+)
+
+// BigCommaf produces a string form of the given big.Float in base 10
+// with commas after every three orders of magnitude.
+func BigCommaf(v *big.Float) string {
+        buf := &bytes.Buffer{}
+        if v.Sign() < 0 {
+                buf.Write([]byte{'-'})
+                v.Abs(v)
+        }
+
+        comma := []byte{','}
+
+        parts := strings.Split(v.Text('f', -1), ".")
+        pos := 0
+        if len(parts[0])%3 != 0 {
+                pos += len(parts[0]) % 3
+                buf.WriteString(parts[0][:pos])
+                buf.Write(comma)
+        }
+        for ; pos < len(parts[0]); pos += 3 {
+                buf.WriteString(parts[0][pos : pos+3])
+                buf.Write(comma)
+        }
+        buf.Truncate(buf.Len() - 1)
+
+        if len(parts) > 1 {
+                buf.Write([]byte{'.'})
+                buf.WriteString(parts[1])
+        }
+        return buf.String()
+}
diff --git a/vendor/github.com/dustin/go-humanize/ftoa.go b/vendor/github.com/dustin/go-humanize/ftoa.go
new file mode 100644
index 0000000..bce923f
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/ftoa.go
@@ -0,0 +1,49 @@
+package humanize
+
+import (
+        "strconv"
+        "strings"
+)
+
+func stripTrailingZeros(s string) string {
+        if !strings.ContainsRune(s, '.') {
+                return s
+        }
+        offset := len(s) - 1
+        for offset > 0 {
+                if s[offset] == '.' {
+                        offset--
+                        break
+                }
+                if s[offset] != '0' {
+                        break
+                }
+                offset--
+        }
+        return s[:offset+1]
+}
+
+func stripTrailingDigits(s string, digits int) string {
+        if i := strings.Index(s, "."); i >= 0 {
+                if digits <= 0 {
+                        return s[:i]
+                }
+                i++
+                if i+digits >= len(s) {
+                        return s
+                }
+                return s[:i+digits]
+        }
+        return s
+}
+
+// Ftoa converts a float to a string with no trailing zeros.
+func Ftoa(num float64) string {
+        return stripTrailingZeros(strconv.FormatFloat(num, 'f', 6, 64))
+}
+
+// FtoaWithDigits converts a float to a string but limits the resulting string
+// to the given number of decimal places, and no trailing zeros.
+func FtoaWithDigits(num float64, digits int) string {
+        return stripTrailingZeros(stripTrailingDigits(strconv.FormatFloat(num, 'f', 6, 64), digits))
+}
diff --git a/vendor/github.com/dustin/go-humanize/humanize.go b/vendor/github.com/dustin/go-humanize/humanize.go
new file mode 100644
index 0000000..a2c2da3
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/humanize.go
@@ -0,0 +1,8 @@
+/*
+Package humanize converts boring ugly numbers to human-friendly strings and back.
+
+Durations can be turned into strings such as "3 days ago", numbers
+representing sizes like 82854982 into useful strings like, "83 MB" or
+"79 MiB" (whichever you prefer).
+*/
+package humanize
diff --git a/vendor/github.com/dustin/go-humanize/number.go b/vendor/github.com/dustin/go-humanize/number.go
new file mode 100644
index 0000000..6470d0d
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/number.go
@@ -0,0 +1,192 @@
+package humanize
+
+/*
+Slightly adapted from the source to fit go-humanize.
+
+Author: https://github.com/gorhill
+Source: https://gist.github.com/gorhill/5285193
+
+*/
+
+import (
+        "math"
+        "strconv"
+)
+
+var (
+        renderFloatPrecisionMultipliers = [...]float64{
+                1,
+                10,
+                100,
+                1000,
+                10000,
+                100000,
+                1000000,
+                10000000,
+                100000000,
+                1000000000,
+        }
+
+        renderFloatPrecisionRounders = [...]float64{
+                0.5,
+                0.05,
+                0.005,
+                0.0005,
+                0.00005,
+                0.000005,
+                0.0000005,
+                0.00000005,
+                0.000000005,
+                0.0000000005,
+        }
+)
+
+// FormatFloat produces a formatted number as string based on the following user-specified criteria:
+// * thousands separator
+// * decimal separator
+// * decimal precision
+//
+// Usage: s := RenderFloat(format, n)
+// The format parameter tells how to render the number n.
+//
+// See examples: http://play.golang.org/p/LXc1Ddm1lJ
+//
+// Examples of format strings, given n = 12345.6789:
+// "#,###.##" => "12,345.67"
+// "#,###." => "12,345"
+// "#,###" => "12345,678"
+// "#\u202F###,##" => "12 345,68"
+// "#.###,###### => 12.345,678900
+// "" (aka default format) => 12,345.67
+//
+// The highest precision allowed is 9 digits after the decimal symbol.
+// There is also a version for integer number, FormatInteger(),
+// which is convenient for calls within template.
+func FormatFloat(format string, n float64) string {
+        // Special cases:
+        //   NaN = "NaN"
+        //   +Inf = "+Infinity"
+        //   -Inf = "-Infinity"
+        if math.IsNaN(n) {
+                return "NaN"
+        }
+        if n > math.MaxFloat64 {
+                return "Infinity"
+        }
+        if n < (0.0 - math.MaxFloat64) {
+                return "-Infinity"
+        }
+
+        // default format
+        precision := 2
+        decimalStr := "."
+        thousandStr := ","
+        positiveStr := ""
+        negativeStr := "-"
+
+        if len(format) > 0 {
+                format := []rune(format)
+
+                // If there is an explicit format directive,
+                // then default values are these:
+                precision = 9
+                thousandStr = ""
+
+                // collect indices of meaningful formatting directives
+                formatIndx := []int{}
+                for i, char := range format {
+                        if char != '#' && char != '0' {
+                                formatIndx = append(formatIndx, i)
+                        }
+                }
+
+                if len(formatIndx) > 0 {
+                        // Directive at index 0:
+                        //   Must be a '+'
+                        //   Raise an error if not the case
+                        // index: 0123456789
+                        //        +0.000,000
+                        //        +000,000.0
+                        //        +0000.00
+                        //        +0000
+                        if formatIndx[0] == 0 {
+                                if format[formatIndx[0]] != '+' {
+                                        panic("RenderFloat(): invalid positive sign directive")
+                                }
+                                positiveStr = "+"
+                                formatIndx = formatIndx[1:]
+                        }
+
+                        // Two directives:
+                        //   First is thousands separator
+                        //   Raise an error if not followed by 3-digit
+                        // 0123456789
+                        // 0.000,000
+                        // 000,000.00
+                        if len(formatIndx) == 2 {
+                                if (formatIndx[1] - formatIndx[0]) != 4 {
+                                        panic("RenderFloat(): thousands separator directive must be followed by 3 digit-specifiers")
+                                }
+                                thousandStr = string(format[formatIndx[0]])
+                                formatIndx = formatIndx[1:]
+                        }
+
+                        // One directive:
+                        //   Directive is decimal separator
+                        //   The number of digit-specifier following the separator indicates wanted precision
+                        // 0123456789
+                        // 0.00
+                        // 000,0000
+                        if len(formatIndx) == 1 {
+                                decimalStr = string(format[formatIndx[0]])
+                                precision = len(format) - formatIndx[0] - 1
+                        }
+                }
+        }
+
+        // generate sign part
+        var signStr string
+        if n >= 0.000000001 {
+                signStr = positiveStr
+        } else if n <= -0.000000001 {
+                signStr = negativeStr
+                n = -n
+        } else {
+                signStr = ""
+                n = 0.0
+        }
+
+        // split number into integer and fractional parts
+        intf, fracf := math.Modf(n + renderFloatPrecisionRounders[precision])
+
+        // generate integer part string
+        intStr := strconv.FormatInt(int64(intf), 10)
+
+        // add thousand separator if required
+        if len(thousandStr) > 0 {
+                for i := len(intStr); i > 3; {
+                        i -= 3
+                        intStr = intStr[:i] + thousandStr + intStr[i:]
+                }
+        }
+
+        // no fractional part, we can leave now
+        if precision == 0 {
+                return signStr + intStr
+        }
+
+        // generate fractional part
+        fracStr := strconv.Itoa(int(fracf * renderFloatPrecisionMultipliers[precision]))
+        // may need padding
+        if len(fracStr) < precision {
+                fracStr = "000000000000000"[:precision-len(fracStr)] + fracStr
+        }
+
+        return signStr + intStr + decimalStr + fracStr
+}
+
+// FormatInteger produces a formatted number as string.
+// See FormatFloat.
+func FormatInteger(format string, n int) string {
+        return FormatFloat(format, float64(n))
+}
diff --git a/vendor/github.com/dustin/go-humanize/ordinals.go b/vendor/github.com/dustin/go-humanize/ordinals.go
new file mode 100644
index 0000000..43d88a8
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/ordinals.go
@@ -0,0 +1,25 @@
+package humanize
+
+import "strconv"
+
+// Ordinal gives you the input number in a rank/ordinal format.
+//
+// Ordinal(3) -> 3rd
+func Ordinal(x int) string {
+        suffix := "th"
+        switch x % 10 {
+        case 1:
+                if x%100 != 11 {
+                        suffix = "st"
+                }
+        case 2:
+                if x%100 != 12 {
+                        suffix = "nd"
+                }
+        case 3:
+                if x%100 != 13 {
+                        suffix = "rd"
+                }
+        }
+        return strconv.Itoa(x) + suffix
+}
diff --git a/vendor/github.com/dustin/go-humanize/si.go b/vendor/github.com/dustin/go-humanize/si.go
new file mode 100644
index 0000000..8b85019
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/si.go
@@ -0,0 +1,127 @@
+package humanize
+
+import (
+        "errors"
+        "math"
+        "regexp"
+        "strconv"
+)
+
+var siPrefixTable = map[float64]string{
+        -30: "q", // quecto
+        -27: "r", // ronto
+        -24: "y", // yocto
+        -21: "z", // zepto
+        -18: "a", // atto
+        -15: "f", // femto
+        -12: "p", // pico
+        -9:  "n", // nano
+        -6:  "µ", // micro
+        -3:  "m", // milli
+        0:   "",
+        3:   "k", // kilo
+        6:   "M", // mega
+        9:   "G", // giga
+        12:  "T", // tera
+        15:  "P", // peta
+        18:  "E", // exa
+        21:  "Z", // zetta
+        24:  "Y", // yotta
+        27:  "R", // ronna
+        30:  "Q", // quetta
+}
+
+var revSIPrefixTable = revfmap(siPrefixTable)
+
+// revfmap reverses the map and precomputes the power multiplier
+func revfmap(in map[float64]string) map[string]float64 {
+        rv := map[string]float64{}
+        for k, v := range in {
+                rv[v] = math.Pow(10, k)
+        }
+        return rv
+}
+
+var riParseRegex *regexp.Regexp
+
+func init() {
+        ri := `^([\-0-9.]+)\s?([`
+        for _, v := range siPrefixTable {
+                ri += v
+        }
+        ri += `]?)(.*)`
+
+        riParseRegex = regexp.MustCompile(ri)
+}
+
+// ComputeSI finds the most appropriate SI prefix for the given number
+// and returns the prefix along with the value adjusted to be within
+// that prefix.
+//
+// See also: SI, ParseSI.
+//
+// e.g. ComputeSI(2.2345e-12) -> (2.2345, "p")
+func ComputeSI(input float64) (float64, string) {
+        if input == 0 {
+                return 0, ""
+        }
+        mag := math.Abs(input)
+        exponent := math.Floor(logn(mag, 10))
+        exponent = math.Floor(exponent/3) * 3
+
+        value := mag / math.Pow(10, exponent)
+
+        // Handle special case where value is exactly 1000.0
+        // Should return 1 M instead of 1000 k
+        if value == 1000.0 {
+                exponent += 3
+                value = mag / math.Pow(10, exponent)
+        }
+
+        value = math.Copysign(value, input)
+
+        prefix := siPrefixTable[exponent]
+        return value, prefix
+}
+
+// SI returns a string with default formatting.
+//
+// SI uses Ftoa to format float value, removing trailing zeros.
+//
+// See also: ComputeSI, ParseSI.
+//
+// e.g. SI(1000000, "B") -> 1 MB
+// e.g. SI(2.2345e-12, "F") -> 2.2345 pF
+func SI(input float64, unit string) string {
+        value, prefix := ComputeSI(input)
+        return Ftoa(value) + " " + prefix + unit
+}
+
+// SIWithDigits works like SI but limits the resulting string to the
+// given number of decimal places.
+//
+// e.g. SIWithDigits(1000000, 0, "B") -> 1 MB
+// e.g. SIWithDigits(2.2345e-12, 2, "F") -> 2.23 pF
+func SIWithDigits(input float64, decimals int, unit string) string {
+        value, prefix := ComputeSI(input)
+        return FtoaWithDigits(value, decimals) + " " + prefix + unit
+}
+
+var errInvalid = errors.New("invalid input")
+
+// ParseSI parses an SI string back into the number and unit.
+//
+// See also: SI, ComputeSI.
+//
+// e.g. ParseSI("2.2345 pF") -> (2.2345e-12, "F", nil)
+func ParseSI(input string) (float64, string, error) {
+        found := riParseRegex.FindStringSubmatch(input)
+        if len(found) != 4 {
+                return 0, "", errInvalid
+        }
+        mag := revSIPrefixTable[found[2]]
+        unit := found[3]
+
+        base, err := strconv.ParseFloat(found[1], 64)
+        return base * mag, unit, err
+}
diff --git a/vendor/github.com/dustin/go-humanize/times.go b/vendor/github.com/dustin/go-humanize/times.go
new file mode 100644
index 0000000..dd3fbf5
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/times.go
@@ -0,0 +1,117 @@
+package humanize
+
+import (
+        "fmt"
+        "math"
+        "sort"
+        "time"
+)
+
+// Seconds-based time units
+const (
+        Day      = 24 * time.Hour
+        Week     = 7 * Day
+        Month    = 30 * Day
+        Year     = 12 * Month
+        LongTime = 37 * Year
+)
+
+// Time formats a time into a relative string.
+//
+// Time(someT) -> "3 weeks ago"
+func Time(then time.Time) string {
+        return RelTime(then, time.Now(), "ago", "from now")
+}
+
+// A RelTimeMagnitude struct contains a relative time point at which
+// the relative format of time will switch to a new format string.  A
+// slice of these in ascending order by their "D" field is passed to
+// CustomRelTime to format durations.
+//
+// The Format field is a string that may contain a "%s" which will be
+// replaced with the appropriate signed label (e.g. "ago" or "from
+// now") and a "%d" that will be replaced by the quantity.
+//
+// The DivBy field is the amount of time the time difference must be
+// divided by in order to display correctly.
+//
+// e.g. if D is 2*time.Minute and you want to display "%d minutes %s"
+// DivBy should be time.Minute so whatever the duration is will be
+// expressed in minutes.
+type RelTimeMagnitude struct {
+        D      time.Duration
+        Format string
+        DivBy  time.Duration
+}
+
+var defaultMagnitudes = []RelTimeMagnitude{
+        {time.Second, "now", time.Second},
+        {2 * time.Second, "1 second %s", 1},
+        {time.Minute, "%d seconds %s", time.Second},
+        {2 * time.Minute, "1 minute %s", 1},
+        {time.Hour, "%d minutes %s", time.Minute},
+        {2 * time.Hour, "1 hour %s", 1},
+        {Day, "%d hours %s", time.Hour},
+        {2 * Day, "1 day %s", 1},
+        {Week, "%d days %s", Day},
+        {2 * Week, "1 week %s", 1},
+        {Month, "%d weeks %s", Week},
+        {2 * Month, "1 month %s", 1},
+        {Year, "%d months %s", Month},
+        {18 * Month, "1 year %s", 1},
+        {2 * Year, "2 years %s", 1},
+        {LongTime, "%d years %s", Year},
+        {math.MaxInt64, "a long while %s", 1},
+}
+
+// RelTime formats a time into a relative string.
+//
+// It takes two times and two labels.  In addition to the generic time
+// delta string (e.g. 5 minutes), the labels are used applied so that
+// the label corresponding to the smaller time is applied.
+//
+// RelTime(timeInPast, timeInFuture, "earlier", "later") -> "3 weeks earlier"
+func RelTime(a, b time.Time, albl, blbl string) string {
+        return CustomRelTime(a, b, albl, blbl, defaultMagnitudes)
+}
+
+// CustomRelTime formats a time into a relative string.
+//
+// It takes two times two labels and a table of relative time formats.
+// In addition to the generic time delta string (e.g. 5 minutes), the
+// labels are used applied so that the label corresponding to the
+// smaller time is applied.
+func CustomRelTime(a, b time.Time, albl, blbl string, magnitudes []RelTimeMagnitude) string {
+        lbl := albl
+        diff := b.Sub(a)
+
+        if a.After(b) {
+                lbl = blbl
+                diff = a.Sub(b)
+        }
+
+        n := sort.Search(len(magnitudes), func(i int) bool {
+                return magnitudes[i].D > diff
+        })
+
+        if n >= len(magnitudes) {
+                n = len(magnitudes) - 1
+        }
+        mag := magnitudes[n]
+        args := []interface{}{}
+        escaped := false
+        for _, ch := range mag.Format {
+                if escaped {
+                        switch ch {
+                        case 's':
+                                args = append(args, lbl)
+                        case 'd':
+                                args = append(args, diff/mag.DivBy)
+                        }
+                        escaped = false
+                } else {
+                        escaped = ch == '%'
+                }
+        }
+        return fmt.Sprintf(mag.Format, args...)
+}
diff --git a/vendor/github.com/google/uuid/CHANGELOG.md b/vendor/github.com/google/uuid/CHANGELOG.md
new file mode 100644
index 0000000..c9fb829
--- /dev/null
+++ b/vendor/github.com/google/uuid/CHANGELOG.md
@@ -0,0 +1,28 @@
+# Changelog
+
+## [1.5.0](https://github.com/google/uuid/compare/v1.4.0...v1.5.0) (2023-12-12)
+
+
+### Features
+
+* Validate UUID without creating new UUID ([#141](https://github.com/google/uuid/issues/141)) ([9ee7366](https://github.com/google/uuid/commit/9ee7366e66c9ad96bab89139418a713dc584ae29))
+
+## [1.4.0](https://github.com/google/uuid/compare/v1.3.1...v1.4.0) (2023-10-26)
+
+
+### Features
+
+* UUIDs slice type with Strings() convenience method ([#133](https://github.com/google/uuid/issues/133)) ([cd5fbbd](https://github.com/google/uuid/commit/cd5fbbdd02f3e3467ac18940e07e062be1f864b4))
+
+### Fixes
+
+* Clarify that Parse's job is to parse but not necessarily validate strings. (Documents current behavior)
+
+## [1.3.1](https://github.com/google/uuid/compare/v1.3.0...v1.3.1) (2023-08-18)
+
+
+### Bug Fixes
+
+* Use .EqualFold() to parse urn prefixed UUIDs ([#118](https://github.com/google/uuid/issues/118)) ([574e687](https://github.com/google/uuid/commit/574e6874943741fb99d41764c705173ada5293f0))
+
+## Changelog
diff --git a/vendor/github.com/google/uuid/CONTRIBUTING.md b/vendor/github.com/google/uuid/CONTRIBUTING.md
new file mode 100644
index 0000000..a502fdc
--- /dev/null
+++ b/vendor/github.com/google/uuid/CONTRIBUTING.md
@@ -0,0 +1,26 @@
+# How to contribute
+
+We definitely welcome patches and contribution to this project!
+
+### Tips
+
+Commits must be formatted according to the [Conventional Commits Specification](https://www.conventionalcommits.org).
+
+Always try to include a test case! If it is not possible or not necessary,
+please explain why in the pull request description.
+
+### Releasing
+
+Commits that would precipitate a SemVer change, as described in the Conventional
+Commits Specification, will trigger [`release-please`](https://github.com/google-github-actions/release-please-action)
+to create a release candidate pull request. Once submitted, `release-please`
+will create a release.
+
+For tips on how to work with `release-please`, see its documentation.
+
+### Legal requirements
+
+In order to protect both you and ourselves, you will need to sign the
+[Contributor License Agreement](https://cla.developers.google.com/clas).
+
+You may have already signed it for other Google projects.
diff --git a/vendor/github.com/google/uuid/CONTRIBUTORS b/vendor/github.com/google/uuid/CONTRIBUTORS
new file mode 100644
index 0000000..b4bb97f
--- /dev/null
+++ b/vendor/github.com/google/uuid/CONTRIBUTORS
@@ -0,0 +1,9 @@
+Paul Borman <[email protected]>
+bmatsuo
+shawnps
+theory
+jboverfelt
+dsymonds
+cd1
+wallclockbuilder
+dansouza
diff --git a/vendor/github.com/google/uuid/LICENSE b/vendor/github.com/google/uuid/LICENSE
new file mode 100644
index 0000000..5dc6826
--- /dev/null
+++ b/vendor/github.com/google/uuid/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2009,2014 Google Inc. 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.
diff --git a/vendor/github.com/google/uuid/README.md b/vendor/github.com/google/uuid/README.md
new file mode 100644
index 0000000..3e9a618
--- /dev/null
+++ b/vendor/github.com/google/uuid/README.md
@@ -0,0 +1,21 @@
+# uuid
+The uuid package generates and inspects UUIDs based on
+[RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122)
+and DCE 1.1: Authentication and Security Services. 
+
+This package is based on the github.com/pborman/uuid package (previously named
+code.google.com/p/go-uuid).  It differs from these earlier packages in that
+a UUID is a 16 byte array rather than a byte slice.  One loss due to this
+change is the ability to represent an invalid UUID (vs a NIL UUID).
+
+###### Install
+```sh
+go get github.com/google/uuid
+```
+
+###### Documentation 
+[![Go Reference](https://pkg.go.dev/badge/github.com/google/uuid.svg)](https://pkg.go.dev/github.com/google/uuid)
+
+Full `go doc` style documentation for the package can be viewed online without
+installing this package by using the GoDoc site here: 
+http://pkg.go.dev/github.com/google/uuid
diff --git a/vendor/github.com/google/uuid/dce.go b/vendor/github.com/google/uuid/dce.go
new file mode 100644
index 0000000..fa820b9
--- /dev/null
+++ b/vendor/github.com/google/uuid/dce.go
@@ -0,0 +1,80 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+        "encoding/binary"
+        "fmt"
+        "os"
+)
+
+// A Domain represents a Version 2 domain
+type Domain byte
+
+// Domain constants for DCE Security (Version 2) UUIDs.
+const (
+        Person = Domain(0)
+        Group  = Domain(1)
+        Org    = Domain(2)
+)
+
+// NewDCESecurity returns a DCE Security (Version 2) UUID.
+//
+// The domain should be one of Person, Group or Org.
+// On a POSIX system the id should be the users UID for the Person
+// domain and the users GID for the Group.  The meaning of id for
+// the domain Org or on non-POSIX systems is site defined.
+//
+// For a given domain/id pair the same token may be returned for up to
+// 7 minutes and 10 seconds.
+func NewDCESecurity(domain Domain, id uint32) (UUID, error) {
+        uuid, err := NewUUID()
+        if err == nil {
+                uuid[6] = (uuid[6] & 0x0f) | 0x20 // Version 2
+                uuid[9] = byte(domain)
+                binary.BigEndian.PutUint32(uuid[0:], id)
+        }
+        return uuid, err
+}
+
+// NewDCEPerson returns a DCE Security (Version 2) UUID in the person
+// domain with the id returned by os.Getuid.
+//
+//  NewDCESecurity(Person, uint32(os.Getuid()))
+func NewDCEPerson() (UUID, error) {
+        return NewDCESecurity(Person, uint32(os.Getuid()))
+}
+
+// NewDCEGroup returns a DCE Security (Version 2) UUID in the group
+// domain with the id returned by os.Getgid.
+//
+//  NewDCESecurity(Group, uint32(os.Getgid()))
+func NewDCEGroup() (UUID, error) {
+        return NewDCESecurity(Group, uint32(os.Getgid()))
+}
+
+// Domain returns the domain for a Version 2 UUID.  Domains are only defined
+// for Version 2 UUIDs.
+func (uuid UUID) Domain() Domain {
+        return Domain(uuid[9])
+}
+
+// ID returns the id for a Version 2 UUID. IDs are only defined for Version 2
+// UUIDs.
+func (uuid UUID) ID() uint32 {
+        return binary.BigEndian.Uint32(uuid[0:4])
+}
+
+func (d Domain) String() string {
+        switch d {
+        case Person:
+                return "Person"
+        case Group:
+                return "Group"
+        case Org:
+                return "Org"
+        }
+        return fmt.Sprintf("Domain%d", int(d))
+}
diff --git a/vendor/github.com/google/uuid/doc.go b/vendor/github.com/google/uuid/doc.go
new file mode 100644
index 0000000..5b8a4b9
--- /dev/null
+++ b/vendor/github.com/google/uuid/doc.go
@@ -0,0 +1,12 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package uuid generates and inspects UUIDs.
+//
+// UUIDs are based on RFC 4122 and DCE 1.1: Authentication and Security
+// Services.
+//
+// A UUID is a 16 byte (128 bit) array.  UUIDs may be used as keys to
+// maps or compared directly.
+package uuid
diff --git a/vendor/github.com/google/uuid/hash.go b/vendor/github.com/google/uuid/hash.go
new file mode 100644
index 0000000..b404f4b
--- /dev/null
+++ b/vendor/github.com/google/uuid/hash.go
@@ -0,0 +1,53 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+        "crypto/md5"
+        "crypto/sha1"
+        "hash"
+)
+
+// Well known namespace IDs and UUIDs
+var (
+        NameSpaceDNS  = Must(Parse("6ba7b810-9dad-11d1-80b4-00c04fd430c8"))
+        NameSpaceURL  = Must(Parse("6ba7b811-9dad-11d1-80b4-00c04fd430c8"))
+        NameSpaceOID  = Must(Parse("6ba7b812-9dad-11d1-80b4-00c04fd430c8"))
+        NameSpaceX500 = Must(Parse("6ba7b814-9dad-11d1-80b4-00c04fd430c8"))
+        Nil           UUID // empty UUID, all zeros
+)
+
+// NewHash returns a new UUID derived from the hash of space concatenated with
+// data generated by h.  The hash should be at least 16 byte in length.  The
+// first 16 bytes of the hash are used to form the UUID.  The version of the
+// UUID will be the lower 4 bits of version.  NewHash is used to implement
+// NewMD5 and NewSHA1.
+func NewHash(h hash.Hash, space UUID, data []byte, version int) UUID {
+        h.Reset()
+        h.Write(space[:]) //nolint:errcheck
+        h.Write(data)     //nolint:errcheck
+        s := h.Sum(nil)
+        var uuid UUID
+        copy(uuid[:], s)
+        uuid[6] = (uuid[6] & 0x0f) | uint8((version&0xf)<<4)
+        uuid[8] = (uuid[8] & 0x3f) | 0x80 // RFC 4122 variant
+        return uuid
+}
+
+// NewMD5 returns a new MD5 (Version 3) UUID based on the
+// supplied name space and data.  It is the same as calling:
+//
+//  NewHash(md5.New(), space, data, 3)
+func NewMD5(space UUID, data []byte) UUID {
+        return NewHash(md5.New(), space, data, 3)
+}
+
+// NewSHA1 returns a new SHA1 (Version 5) UUID based on the
+// supplied name space and data.  It is the same as calling:
+//
+//  NewHash(sha1.New(), space, data, 5)
+func NewSHA1(space UUID, data []byte) UUID {
+        return NewHash(sha1.New(), space, data, 5)
+}
diff --git a/vendor/github.com/google/uuid/marshal.go b/vendor/github.com/google/uuid/marshal.go
new file mode 100644
index 0000000..14bd340
--- /dev/null
+++ b/vendor/github.com/google/uuid/marshal.go
@@ -0,0 +1,38 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import "fmt"
+
+// MarshalText implements encoding.TextMarshaler.
+func (uuid UUID) MarshalText() ([]byte, error) {
+        var js [36]byte
+        encodeHex(js[:], uuid)
+        return js[:], nil
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler.
+func (uuid *UUID) UnmarshalText(data []byte) error {
+        id, err := ParseBytes(data)
+        if err != nil {
+                return err
+        }
+        *uuid = id
+        return nil
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler.
+func (uuid UUID) MarshalBinary() ([]byte, error) {
+        return uuid[:], nil
+}
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler.
+func (uuid *UUID) UnmarshalBinary(data []byte) error {
+        if len(data) != 16 {
+                return fmt.Errorf("invalid UUID (got %d bytes)", len(data))
+        }
+        copy(uuid[:], data)
+        return nil
+}
diff --git a/vendor/github.com/google/uuid/node.go b/vendor/github.com/google/uuid/node.go
new file mode 100644
index 0000000..d651a2b
--- /dev/null
+++ b/vendor/github.com/google/uuid/node.go
@@ -0,0 +1,90 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+        "sync"
+)
+
+var (
+        nodeMu sync.Mutex
+        ifname string  // name of interface being used
+        nodeID [6]byte // hardware for version 1 UUIDs
+        zeroID [6]byte // nodeID with only 0's
+)
+
+// NodeInterface returns the name of the interface from which the NodeID was
+// derived.  The interface "user" is returned if the NodeID was set by
+// SetNodeID.
+func NodeInterface() string {
+        defer nodeMu.Unlock()
+        nodeMu.Lock()
+        return ifname
+}
+
+// SetNodeInterface selects the hardware address to be used for Version 1 UUIDs.
+// If name is "" then the first usable interface found will be used or a random
+// Node ID will be generated.  If a named interface cannot be found then false
+// is returned.
+//
+// SetNodeInterface never fails when name is "".
+func SetNodeInterface(name string) bool {
+        defer nodeMu.Unlock()
+        nodeMu.Lock()
+        return setNodeInterface(name)
+}
+
+func setNodeInterface(name string) bool {
+        iname, addr := getHardwareInterface(name) // null implementation for js
+        if iname != "" && addr != nil {
+                ifname = iname
+                copy(nodeID[:], addr)
+                return true
+        }
+
+        // We found no interfaces with a valid hardware address.  If name
+        // does not specify a specific interface generate a random Node ID
+        // (section 4.1.6)
+        if name == "" {
+                ifname = "random"
+                randomBits(nodeID[:])
+                return true
+        }
+        return false
+}
+
+// NodeID returns a slice of a copy of the current Node ID, setting the Node ID
+// if not already set.
+func NodeID() []byte {
+        defer nodeMu.Unlock()
+        nodeMu.Lock()
+        if nodeID == zeroID {
+                setNodeInterface("")
+        }
+        nid := nodeID
+        return nid[:]
+}
+
+// SetNodeID sets the Node ID to be used for Version 1 UUIDs.  The first 6 bytes
+// of id are used.  If id is less than 6 bytes then false is returned and the
+// Node ID is not set.
+func SetNodeID(id []byte) bool {
+        if len(id) < 6 {
+                return false
+        }
+        defer nodeMu.Unlock()
+        nodeMu.Lock()
+        copy(nodeID[:], id)
+        ifname = "user"
+        return true
+}
+
+// NodeID returns the 6 byte node id encoded in uuid.  It returns nil if uuid is
+// not valid.  The NodeID is only well defined for version 1 and 2 UUIDs.
+func (uuid UUID) NodeID() []byte {
+        var node [6]byte
+        copy(node[:], uuid[10:])
+        return node[:]
+}
diff --git a/vendor/github.com/google/uuid/node_js.go b/vendor/github.com/google/uuid/node_js.go
new file mode 100644
index 0000000..b2a0bc8
--- /dev/null
+++ b/vendor/github.com/google/uuid/node_js.go
@@ -0,0 +1,12 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build js
+
+package uuid
+
+// getHardwareInterface returns nil values for the JS version of the code.
+// This removes the "net" dependency, because it is not used in the browser.
+// Using the "net" library inflates the size of the transpiled JS code by 673k bytes.
+func getHardwareInterface(name string) (string, []byte) { return "", nil }
diff --git a/vendor/github.com/google/uuid/node_net.go b/vendor/github.com/google/uuid/node_net.go
new file mode 100644
index 0000000..0cbbcdd
--- /dev/null
+++ b/vendor/github.com/google/uuid/node_net.go
@@ -0,0 +1,33 @@
+// Copyright 2017 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !js
+
+package uuid
+
+import "net"
+
+var interfaces []net.Interface // cached list of interfaces
+
+// getHardwareInterface returns the name and hardware address of interface name.
+// If name is "" then the name and hardware address of one of the system's
+// interfaces is returned.  If no interfaces are found (name does not exist or
+// there are no interfaces) then "", nil is returned.
+//
+// Only addresses of at least 6 bytes are returned.
+func getHardwareInterface(name string) (string, []byte) {
+        if interfaces == nil {
+                var err error
+                interfaces, err = net.Interfaces()
+                if err != nil {
+                        return "", nil
+                }
+        }
+        for _, ifs := range interfaces {
+                if len(ifs.HardwareAddr) >= 6 && (name == "" || name == ifs.Name) {
+                        return ifs.Name, ifs.HardwareAddr
+                }
+        }
+        return "", nil
+}
diff --git a/vendor/github.com/google/uuid/null.go b/vendor/github.com/google/uuid/null.go
new file mode 100644
index 0000000..d7fcbf2
--- /dev/null
+++ b/vendor/github.com/google/uuid/null.go
@@ -0,0 +1,118 @@
+// Copyright 2021 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+        "bytes"
+        "database/sql/driver"
+        "encoding/json"
+        "fmt"
+)
+
+var jsonNull = []byte("null")
+
+// NullUUID represents a UUID that may be null.
+// NullUUID implements the SQL driver.Scanner interface so
+// it can be used as a scan destination:
+//
+//  var u uuid.NullUUID
+//  err := db.QueryRow("SELECT name FROM foo WHERE id=?", id).Scan(&u)
+//  ...
+//  if u.Valid {
+//     // use u.UUID
+//  } else {
+//     // NULL value
+//  }
+//
+type NullUUID struct {
+        UUID  UUID
+        Valid bool // Valid is true if UUID is not NULL
+}
+
+// Scan implements the SQL driver.Scanner interface.
+func (nu *NullUUID) Scan(value interface{}) error {
+        if value == nil {
+                nu.UUID, nu.Valid = Nil, false
+                return nil
+        }
+
+        err := nu.UUID.Scan(value)
+        if err != nil {
+                nu.Valid = false
+                return err
+        }
+
+        nu.Valid = true
+        return nil
+}
+
+// Value implements the driver Valuer interface.
+func (nu NullUUID) Value() (driver.Value, error) {
+        if !nu.Valid {
+                return nil, nil
+        }
+        // Delegate to UUID Value function
+        return nu.UUID.Value()
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler.
+func (nu NullUUID) MarshalBinary() ([]byte, error) {
+        if nu.Valid {
+                return nu.UUID[:], nil
+        }
+
+        return []byte(nil), nil
+}
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler.
+func (nu *NullUUID) UnmarshalBinary(data []byte) error {
+        if len(data) != 16 {
+                return fmt.Errorf("invalid UUID (got %d bytes)", len(data))
+        }
+        copy(nu.UUID[:], data)
+        nu.Valid = true
+        return nil
+}
+
+// MarshalText implements encoding.TextMarshaler.
+func (nu NullUUID) MarshalText() ([]byte, error) {
+        if nu.Valid {
+                return nu.UUID.MarshalText()
+        }
+
+        return jsonNull, nil
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler.
+func (nu *NullUUID) UnmarshalText(data []byte) error {
+        id, err := ParseBytes(data)
+        if err != nil {
+                nu.Valid = false
+                return err
+        }
+        nu.UUID = id
+        nu.Valid = true
+        return nil
+}
+
+// MarshalJSON implements json.Marshaler.
+func (nu NullUUID) MarshalJSON() ([]byte, error) {
+        if nu.Valid {
+                return json.Marshal(nu.UUID)
+        }
+
+        return jsonNull, nil
+}
+
+// UnmarshalJSON implements json.Unmarshaler.
+func (nu *NullUUID) UnmarshalJSON(data []byte) error {
+        if bytes.Equal(data, jsonNull) {
+                *nu = NullUUID{}
+                return nil // valid null UUID
+        }
+        err := json.Unmarshal(data, &nu.UUID)
+        nu.Valid = err == nil
+        return err
+}
diff --git a/vendor/github.com/google/uuid/sql.go b/vendor/github.com/google/uuid/sql.go
new file mode 100644
index 0000000..2e02ec0
--- /dev/null
+++ b/vendor/github.com/google/uuid/sql.go
@@ -0,0 +1,59 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+        "database/sql/driver"
+        "fmt"
+)
+
+// Scan implements sql.Scanner so UUIDs can be read from databases transparently.
+// Currently, database types that map to string and []byte are supported. Please
+// consult database-specific driver documentation for matching types.
+func (uuid *UUID) Scan(src interface{}) error {
+        switch src := src.(type) {
+        case nil:
+                return nil
+
+        case string:
+                // if an empty UUID comes from a table, we return a null UUID
+                if src == "" {
+                        return nil
+                }
+
+                // see Parse for required string format
+                u, err := Parse(src)
+                if err != nil {
+                        return fmt.Errorf("Scan: %v", err)
+                }
+
+                *uuid = u
+
+        case []byte:
+                // if an empty UUID comes from a table, we return a null UUID
+                if len(src) == 0 {
+                        return nil
+                }
+
+                // assumes a simple slice of bytes if 16 bytes
+                // otherwise attempts to parse
+                if len(src) != 16 {
+                        return uuid.Scan(string(src))
+                }
+                copy((*uuid)[:], src)
+
+        default:
+                return fmt.Errorf("Scan: unable to scan type %T into UUID", src)
+        }
+
+        return nil
+}
+
+// Value implements sql.Valuer so that UUIDs can be written to databases
+// transparently. Currently, UUIDs map to strings. Please consult
+// database-specific driver documentation for matching types.
+func (uuid UUID) Value() (driver.Value, error) {
+        return uuid.String(), nil
+}
diff --git a/vendor/github.com/google/uuid/time.go b/vendor/github.com/google/uuid/time.go
new file mode 100644
index 0000000..c351129
--- /dev/null
+++ b/vendor/github.com/google/uuid/time.go
@@ -0,0 +1,134 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+        "encoding/binary"
+        "sync"
+        "time"
+)
+
+// A Time represents a time as the number of 100's of nanoseconds since 15 Oct
+// 1582.
+type Time int64
+
+const (
+        lillian    = 2299160          // Julian day of 15 Oct 1582
+        unix       = 2440587          // Julian day of 1 Jan 1970
+        epoch      = unix - lillian   // Days between epochs
+        g1582      = epoch * 86400    // seconds between epochs
+        g1582ns100 = g1582 * 10000000 // 100s of a nanoseconds between epochs
+)
+
+var (
+        timeMu   sync.Mutex
+        lasttime uint64 // last time we returned
+        clockSeq uint16 // clock sequence for this run
+
+        timeNow = time.Now // for testing
+)
+
+// UnixTime converts t the number of seconds and nanoseconds using the Unix
+// epoch of 1 Jan 1970.
+func (t Time) UnixTime() (sec, nsec int64) {
+        sec = int64(t - g1582ns100)
+        nsec = (sec % 10000000) * 100
+        sec /= 10000000
+        return sec, nsec
+}
+
+// GetTime returns the current Time (100s of nanoseconds since 15 Oct 1582) and
+// clock sequence as well as adjusting the clock sequence as needed.  An error
+// is returned if the current time cannot be determined.
+func GetTime() (Time, uint16, error) {
+        defer timeMu.Unlock()
+        timeMu.Lock()
+        return getTime()
+}
+
+func getTime() (Time, uint16, error) {
+        t := timeNow()
+
+        // If we don't have a clock sequence already, set one.
+        if clockSeq == 0 {
+                setClockSequence(-1)
+        }
+        now := uint64(t.UnixNano()/100) + g1582ns100
+
+        // If time has gone backwards with this clock sequence then we
+        // increment the clock sequence
+        if now <= lasttime {
+                clockSeq = ((clockSeq + 1) & 0x3fff) | 0x8000
+        }
+        lasttime = now
+        return Time(now), clockSeq, nil
+}
+
+// ClockSequence returns the current clock sequence, generating one if not
+// already set.  The clock sequence is only used for Version 1 UUIDs.
+//
+// The uuid package does not use global static storage for the clock sequence or
+// the last time a UUID was generated.  Unless SetClockSequence is used, a new
+// random clock sequence is generated the first time a clock sequence is
+// requested by ClockSequence, GetTime, or NewUUID.  (section 4.2.1.1)
+func ClockSequence() int {
+        defer timeMu.Unlock()
+        timeMu.Lock()
+        return clockSequence()
+}
+
+func clockSequence() int {
+        if clockSeq == 0 {
+                setClockSequence(-1)
+        }
+        return int(clockSeq & 0x3fff)
+}
+
+// SetClockSequence sets the clock sequence to the lower 14 bits of seq.  Setting to
+// -1 causes a new sequence to be generated.
+func SetClockSequence(seq int) {
+        defer timeMu.Unlock()
+        timeMu.Lock()
+        setClockSequence(seq)
+}
+
+func setClockSequence(seq int) {
+        if seq == -1 {
+                var b [2]byte
+                randomBits(b[:]) // clock sequence
+                seq = int(b[0])<<8 | int(b[1])
+        }
+        oldSeq := clockSeq
+        clockSeq = uint16(seq&0x3fff) | 0x8000 // Set our variant
+        if oldSeq != clockSeq {
+                lasttime = 0
+        }
+}
+
+// Time returns the time in 100s of nanoseconds since 15 Oct 1582 encoded in
+// uuid.  The time is only defined for version 1, 2, 6 and 7 UUIDs.
+func (uuid UUID) Time() Time {
+        var t Time
+        switch uuid.Version() {
+        case 6:
+                time := binary.BigEndian.Uint64(uuid[:8]) // Ignore uuid[6] version b0110
+                t = Time(time)
+        case 7:
+                time := binary.BigEndian.Uint64(uuid[:8])
+                t = Time((time>>16)*10000 + g1582ns100)
+        default: // forward compatible
+                time := int64(binary.BigEndian.Uint32(uuid[0:4]))
+                time |= int64(binary.BigEndian.Uint16(uuid[4:6])) << 32
+                time |= int64(binary.BigEndian.Uint16(uuid[6:8])&0xfff) << 48
+                t = Time(time)
+        }
+        return t
+}
+
+// ClockSequence returns the clock sequence encoded in uuid.
+// The clock sequence is only well defined for version 1 and 2 UUIDs.
+func (uuid UUID) ClockSequence() int {
+        return int(binary.BigEndian.Uint16(uuid[8:10])) & 0x3fff
+}
diff --git a/vendor/github.com/google/uuid/util.go b/vendor/github.com/google/uuid/util.go
new file mode 100644
index 0000000..5ea6c73
--- /dev/null
+++ b/vendor/github.com/google/uuid/util.go
@@ -0,0 +1,43 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+        "io"
+)
+
+// randomBits completely fills slice b with random data.
+func randomBits(b []byte) {
+        if _, err := io.ReadFull(rander, b); err != nil {
+                panic(err.Error()) // rand should never fail
+        }
+}
+
+// xvalues returns the value of a byte as a hexadecimal digit or 255.
+var xvalues = [256]byte{
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 255, 255, 255, 255, 255, 255,
+        255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+}
+
+// xtob converts hex characters x1 and x2 into a byte.
+func xtob(x1, x2 byte) (byte, bool) {
+        b1 := xvalues[x1]
+        b2 := xvalues[x2]
+        return (b1 << 4) | b2, b1 != 255 && b2 != 255
+}
diff --git a/vendor/github.com/google/uuid/uuid.go b/vendor/github.com/google/uuid/uuid.go
new file mode 100644
index 0000000..5232b48
--- /dev/null
+++ b/vendor/github.com/google/uuid/uuid.go
@@ -0,0 +1,365 @@
+// Copyright 2018 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+        "bytes"
+        "crypto/rand"
+        "encoding/hex"
+        "errors"
+        "fmt"
+        "io"
+        "strings"
+        "sync"
+)
+
+// A UUID is a 128 bit (16 byte) Universal Unique IDentifier as defined in RFC
+// 4122.
+type UUID [16]byte
+
+// A Version represents a UUID's version.
+type Version byte
+
+// A Variant represents a UUID's variant.
+type Variant byte
+
+// Constants returned by Variant.
+const (
+        Invalid   = Variant(iota) // Invalid UUID
+        RFC4122                   // The variant specified in RFC4122
+        Reserved                  // Reserved, NCS backward compatibility.
+        Microsoft                 // Reserved, Microsoft Corporation backward compatibility.
+        Future                    // Reserved for future definition.
+)
+
+const randPoolSize = 16 * 16
+
+var (
+        rander      = rand.Reader // random function
+        poolEnabled = false
+        poolMu      sync.Mutex
+        poolPos     = randPoolSize     // protected with poolMu
+        pool        [randPoolSize]byte // protected with poolMu
+)
+
+type invalidLengthError struct{ len int }
+
+func (err invalidLengthError) Error() string {
+        return fmt.Sprintf("invalid UUID length: %d", err.len)
+}
+
+// IsInvalidLengthError is matcher function for custom error invalidLengthError
+func IsInvalidLengthError(err error) bool {
+        _, ok := err.(invalidLengthError)
+        return ok
+}
+
+// Parse decodes s into a UUID or returns an error if it cannot be parsed.  Both
+// the standard UUID forms defined in RFC 4122
+// (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx and
+// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx) are decoded.  In addition,
+// Parse accepts non-standard strings such as the raw hex encoding
+// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx and 38 byte "Microsoft style" encodings,
+// e.g.  {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}.  Only the middle 36 bytes are
+// examined in the latter case.  Parse should not be used to validate strings as
+// it parses non-standard encodings as indicated above.
+func Parse(s string) (UUID, error) {
+        var uuid UUID
+        switch len(s) {
+        // xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+        case 36:
+
+        // urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+        case 36 + 9:
+                if !strings.EqualFold(s[:9], "urn:uuid:") {
+                        return uuid, fmt.Errorf("invalid urn prefix: %q", s[:9])
+                }
+                s = s[9:]
+
+        // {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
+        case 36 + 2:
+                s = s[1:]
+
+        // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+        case 32:
+                var ok bool
+                for i := range uuid {
+                        uuid[i], ok = xtob(s[i*2], s[i*2+1])
+                        if !ok {
+                                return uuid, errors.New("invalid UUID format")
+                        }
+                }
+                return uuid, nil
+        default:
+                return uuid, invalidLengthError{len(s)}
+        }
+        // s is now at least 36 bytes long
+        // it must be of the form  xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+        if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
+                return uuid, errors.New("invalid UUID format")
+        }
+        for i, x := range [16]int{
+                0, 2, 4, 6,
+                9, 11,
+                14, 16,
+                19, 21,
+                24, 26, 28, 30, 32, 34,
+        } {
+                v, ok := xtob(s[x], s[x+1])
+                if !ok {
+                        return uuid, errors.New("invalid UUID format")
+                }
+                uuid[i] = v
+        }
+        return uuid, nil
+}
+
+// ParseBytes is like Parse, except it parses a byte slice instead of a string.
+func ParseBytes(b []byte) (UUID, error) {
+        var uuid UUID
+        switch len(b) {
+        case 36: // xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+        case 36 + 9: // urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+                if !bytes.EqualFold(b[:9], []byte("urn:uuid:")) {
+                        return uuid, fmt.Errorf("invalid urn prefix: %q", b[:9])
+                }
+                b = b[9:]
+        case 36 + 2: // {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
+                b = b[1:]
+        case 32: // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+                var ok bool
+                for i := 0; i < 32; i += 2 {
+                        uuid[i/2], ok = xtob(b[i], b[i+1])
+                        if !ok {
+                                return uuid, errors.New("invalid UUID format")
+                        }
+                }
+                return uuid, nil
+        default:
+                return uuid, invalidLengthError{len(b)}
+        }
+        // s is now at least 36 bytes long
+        // it must be of the form  xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+        if b[8] != '-' || b[13] != '-' || b[18] != '-' || b[23] != '-' {
+                return uuid, errors.New("invalid UUID format")
+        }
+        for i, x := range [16]int{
+                0, 2, 4, 6,
+                9, 11,
+                14, 16,
+                19, 21,
+                24, 26, 28, 30, 32, 34,
+        } {
+                v, ok := xtob(b[x], b[x+1])
+                if !ok {
+                        return uuid, errors.New("invalid UUID format")
+                }
+                uuid[i] = v
+        }
+        return uuid, nil
+}
+
+// MustParse is like Parse but panics if the string cannot be parsed.
+// It simplifies safe initialization of global variables holding compiled UUIDs.
+func MustParse(s string) UUID {
+        uuid, err := Parse(s)
+        if err != nil {
+                panic(`uuid: Parse(` + s + `): ` + err.Error())
+        }
+        return uuid
+}
+
+// FromBytes creates a new UUID from a byte slice. Returns an error if the slice
+// does not have a length of 16. The bytes are copied from the slice.
+func FromBytes(b []byte) (uuid UUID, err error) {
+        err = uuid.UnmarshalBinary(b)
+        return uuid, err
+}
+
+// Must returns uuid if err is nil and panics otherwise.
+func Must(uuid UUID, err error) UUID {
+        if err != nil {
+                panic(err)
+        }
+        return uuid
+}
+
+// Validate returns an error if s is not a properly formatted UUID in one of the following formats:
+//   xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+//   urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+//   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+//   {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
+// It returns an error if the format is invalid, otherwise nil.
+func Validate(s string) error {
+        switch len(s) {
+        // Standard UUID format
+        case 36:
+
+        // UUID with "urn:uuid:" prefix
+        case 36 + 9:
+                if !strings.EqualFold(s[:9], "urn:uuid:") {
+                        return fmt.Errorf("invalid urn prefix: %q", s[:9])
+                }
+                s = s[9:]
+
+        // UUID enclosed in braces
+        case 36 + 2:
+                if s[0] != '{' || s[len(s)-1] != '}' {
+                        return fmt.Errorf("invalid bracketed UUID format")
+                }
+                s = s[1 : len(s)-1]
+
+        // UUID without hyphens
+        case 32:
+                for i := 0; i < len(s); i += 2 {
+                        _, ok := xtob(s[i], s[i+1])
+                        if !ok {
+                                return errors.New("invalid UUID format")
+                        }
+                }
+
+        default:
+                return invalidLengthError{len(s)}
+        }
+
+        // Check for standard UUID format
+        if len(s) == 36 {
+                if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
+                        return errors.New("invalid UUID format")
+                }
+                for _, x := range []int{0, 2, 4, 6, 9, 11, 14, 16, 19, 21, 24, 26, 28, 30, 32, 34} {
+                        if _, ok := xtob(s[x], s[x+1]); !ok {
+                                return errors.New("invalid UUID format")
+                        }
+                }
+        }
+
+        return nil
+}
+
+// String returns the string form of uuid, xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+// , or "" if uuid is invalid.
+func (uuid UUID) String() string {
+        var buf [36]byte
+        encodeHex(buf[:], uuid)
+        return string(buf[:])
+}
+
+// URN returns the RFC 2141 URN form of uuid,
+// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx,  or "" if uuid is invalid.
+func (uuid UUID) URN() string {
+        var buf [36 + 9]byte
+        copy(buf[:], "urn:uuid:")
+        encodeHex(buf[9:], uuid)
+        return string(buf[:])
+}
+
+func encodeHex(dst []byte, uuid UUID) {
+        hex.Encode(dst, uuid[:4])
+        dst[8] = '-'
+        hex.Encode(dst[9:13], uuid[4:6])
+        dst[13] = '-'
+        hex.Encode(dst[14:18], uuid[6:8])
+        dst[18] = '-'
+        hex.Encode(dst[19:23], uuid[8:10])
+        dst[23] = '-'
+        hex.Encode(dst[24:], uuid[10:])
+}
+
+// Variant returns the variant encoded in uuid.
+func (uuid UUID) Variant() Variant {
+        switch {
+        case (uuid[8] & 0xc0) == 0x80:
+                return RFC4122
+        case (uuid[8] & 0xe0) == 0xc0:
+                return Microsoft
+        case (uuid[8] & 0xe0) == 0xe0:
+                return Future
+        default:
+                return Reserved
+        }
+}
+
+// Version returns the version of uuid.
+func (uuid UUID) Version() Version {
+        return Version(uuid[6] >> 4)
+}
+
+func (v Version) String() string {
+        if v > 15 {
+                return fmt.Sprintf("BAD_VERSION_%d", v)
+        }
+        return fmt.Sprintf("VERSION_%d", v)
+}
+
+func (v Variant) String() string {
+        switch v {
+        case RFC4122:
+                return "RFC4122"
+        case Reserved:
+                return "Reserved"
+        case Microsoft:
+                return "Microsoft"
+        case Future:
+                return "Future"
+        case Invalid:
+                return "Invalid"
+        }
+        return fmt.Sprintf("BadVariant%d", int(v))
+}
+
+// SetRand sets the random number generator to r, which implements io.Reader.
+// If r.Read returns an error when the package requests random data then
+// a panic will be issued.
+//
+// Calling SetRand with nil sets the random number generator to the default
+// generator.
+func SetRand(r io.Reader) {
+        if r == nil {
+                rander = rand.Reader
+                return
+        }
+        rander = r
+}
+
+// EnableRandPool enables internal randomness pool used for Random
+// (Version 4) UUID generation. The pool contains random bytes read from
+// the random number generator on demand in batches. Enabling the pool
+// may improve the UUID generation throughput significantly.
+//
+// Since the pool is stored on the Go heap, this feature may be a bad fit
+// for security sensitive applications.
+//
+// Both EnableRandPool and DisableRandPool are not thread-safe and should
+// only be called when there is no possibility that New or any other
+// UUID Version 4 generation function will be called concurrently.
+func EnableRandPool() {
+        poolEnabled = true
+}
+
+// DisableRandPool disables the randomness pool if it was previously
+// enabled with EnableRandPool.
+//
+// Both EnableRandPool and DisableRandPool are not thread-safe and should
+// only be called when there is no possibility that New or any other
+// UUID Version 4 generation function will be called concurrently.
+func DisableRandPool() {
+        poolEnabled = false
+        defer poolMu.Unlock()
+        poolMu.Lock()
+        poolPos = randPoolSize
+}
+
+// UUIDs is a slice of UUID types.
+type UUIDs []UUID
+
+// Strings returns a string slice containing the string form of each UUID in uuids.
+func (uuids UUIDs) Strings() []string {
+        var uuidStrs = make([]string, len(uuids))
+        for i, uuid := range uuids {
+                uuidStrs[i] = uuid.String()
+        }
+        return uuidStrs
+}
diff --git a/vendor/github.com/google/uuid/version1.go b/vendor/github.com/google/uuid/version1.go
new file mode 100644
index 0000000..4631096
--- /dev/null
+++ b/vendor/github.com/google/uuid/version1.go
@@ -0,0 +1,44 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+        "encoding/binary"
+)
+
+// NewUUID returns a Version 1 UUID based on the current NodeID and clock
+// sequence, and the current time.  If the NodeID has not been set by SetNodeID
+// or SetNodeInterface then it will be set automatically.  If the NodeID cannot
+// be set NewUUID returns nil.  If clock sequence has not been set by
+// SetClockSequence then it will be set automatically.  If GetTime fails to
+// return the current NewUUID returns nil and an error.
+//
+// In most cases, New should be used.
+func NewUUID() (UUID, error) {
+        var uuid UUID
+        now, seq, err := GetTime()
+        if err != nil {
+                return uuid, err
+        }
+
+        timeLow := uint32(now & 0xffffffff)
+        timeMid := uint16((now >> 32) & 0xffff)
+        timeHi := uint16((now >> 48) & 0x0fff)
+        timeHi |= 0x1000 // Version 1
+
+        binary.BigEndian.PutUint32(uuid[0:], timeLow)
+        binary.BigEndian.PutUint16(uuid[4:], timeMid)
+        binary.BigEndian.PutUint16(uuid[6:], timeHi)
+        binary.BigEndian.PutUint16(uuid[8:], seq)
+
+        nodeMu.Lock()
+        if nodeID == zeroID {
+                setNodeInterface("")
+        }
+        copy(uuid[10:], nodeID[:])
+        nodeMu.Unlock()
+
+        return uuid, nil
+}
diff --git a/vendor/github.com/google/uuid/version4.go b/vendor/github.com/google/uuid/version4.go
new file mode 100644
index 0000000..7697802
--- /dev/null
+++ b/vendor/github.com/google/uuid/version4.go
@@ -0,0 +1,76 @@
+// Copyright 2016 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import "io"
+
+// New creates a new random UUID or panics.  New is equivalent to
+// the expression
+//
+//    uuid.Must(uuid.NewRandom())
+func New() UUID {
+        return Must(NewRandom())
+}
+
+// NewString creates a new random UUID and returns it as a string or panics.
+// NewString is equivalent to the expression
+//
+//    uuid.New().String()
+func NewString() string {
+        return Must(NewRandom()).String()
+}
+
+// NewRandom returns a Random (Version 4) UUID.
+//
+// The strength of the UUIDs is based on the strength of the crypto/rand
+// package.
+//
+// Uses the randomness pool if it was enabled with EnableRandPool.
+//
+// A note about uniqueness derived from the UUID Wikipedia entry:
+//
+//  Randomly generated UUIDs have 122 random bits.  One's annual risk of being
+//  hit by a meteorite is estimated to be one chance in 17 billion, that
+//  means the probability is about 0.00000000006 (6 × 10−11),
+//  equivalent to the odds of creating a few tens of trillions of UUIDs in a
+//  year and having one duplicate.
+func NewRandom() (UUID, error) {
+        if !poolEnabled {
+                return NewRandomFromReader(rander)
+        }
+        return newRandomFromPool()
+}
+
+// NewRandomFromReader returns a UUID based on bytes read from a given io.Reader.
+func NewRandomFromReader(r io.Reader) (UUID, error) {
+        var uuid UUID
+        _, err := io.ReadFull(r, uuid[:])
+        if err != nil {
+                return Nil, err
+        }
+        uuid[6] = (uuid[6] & 0x0f) | 0x40 // Version 4
+        uuid[8] = (uuid[8] & 0x3f) | 0x80 // Variant is 10
+        return uuid, nil
+}
+
+func newRandomFromPool() (UUID, error) {
+        var uuid UUID
+        poolMu.Lock()
+        if poolPos == randPoolSize {
+                _, err := io.ReadFull(rander, pool[:])
+                if err != nil {
+                        poolMu.Unlock()
+                        return Nil, err
+                }
+                poolPos = 0
+        }
+        copy(uuid[:], pool[poolPos:(poolPos+16)])
+        poolPos += 16
+        poolMu.Unlock()
+
+        uuid[6] = (uuid[6] & 0x0f) | 0x40 // Version 4
+        uuid[8] = (uuid[8] & 0x3f) | 0x80 // Variant is 10
+        return uuid, nil
+}
diff --git a/vendor/github.com/google/uuid/version6.go b/vendor/github.com/google/uuid/version6.go
new file mode 100644
index 0000000..339a959
--- /dev/null
+++ b/vendor/github.com/google/uuid/version6.go
@@ -0,0 +1,56 @@
+// Copyright 2023 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import "encoding/binary"
+
+// UUID version 6 is a field-compatible version of UUIDv1, reordered for improved DB locality.
+// It is expected that UUIDv6 will primarily be used in contexts where there are existing v1 UUIDs.
+// Systems that do not involve legacy UUIDv1 SHOULD consider using UUIDv7 instead.
+//
+// see https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-03#uuidv6
+//
+// NewV6 returns a Version 6 UUID based on the current NodeID and clock
+// sequence, and the current time. If the NodeID has not been set by SetNodeID
+// or SetNodeInterface then it will be set automatically. If the NodeID cannot
+// be set NewV6 set NodeID is random bits automatically . If clock sequence has not been set by
+// SetClockSequence then it will be set automatically. If GetTime fails to
+// return the current NewV6 returns Nil and an error.
+func NewV6() (UUID, error) {
+        var uuid UUID
+        now, seq, err := GetTime()
+        if err != nil {
+                return uuid, err
+        }
+
+        /*
+            0                   1                   2                   3
+            0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+           |                           time_high                           |
+           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+           |           time_mid            |      time_low_and_version     |
+           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+           |clk_seq_hi_res |  clk_seq_low  |         node (0-1)            |
+           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+           |                         node (2-5)                            |
+           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+        */
+
+        binary.BigEndian.PutUint64(uuid[0:], uint64(now))
+        binary.BigEndian.PutUint16(uuid[8:], seq)
+
+        uuid[6] = 0x60 | (uuid[6] & 0x0F)
+        uuid[8] = 0x80 | (uuid[8] & 0x3F)
+
+        nodeMu.Lock()
+        if nodeID == zeroID {
+                setNodeInterface("")
+        }
+        copy(uuid[10:], nodeID[:])
+        nodeMu.Unlock()
+
+        return uuid, nil
+}
diff --git a/vendor/github.com/google/uuid/version7.go b/vendor/github.com/google/uuid/version7.go
new file mode 100644
index 0000000..ba9dd5e
--- /dev/null
+++ b/vendor/github.com/google/uuid/version7.go
@@ -0,0 +1,75 @@
+// Copyright 2023 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+        "io"
+)
+
+// UUID version 7 features a time-ordered value field derived from the widely
+// implemented and well known Unix Epoch timestamp source,
+// the number of milliseconds seconds since midnight 1 Jan 1970 UTC, leap seconds excluded.
+// As well as improved entropy characteristics over versions 1 or 6.
+//
+// see https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-03#name-uuid-version-7
+//
+// Implementations SHOULD utilize UUID version 7 over UUID version 1 and 6 if possible.
+//
+// NewV7 returns a Version 7 UUID based on the current time(Unix Epoch).
+// Uses the randomness pool if it was enabled with EnableRandPool.
+// On error, NewV7 returns Nil and an error
+func NewV7() (UUID, error) {
+        uuid, err := NewRandom()
+        if err != nil {
+                return uuid, err
+        }
+        makeV7(uuid[:])
+        return uuid, nil
+}
+
+// NewV7FromReader returns a Version 7 UUID based on the current time(Unix Epoch).
+// it use NewRandomFromReader fill random bits.
+// On error, NewV7FromReader returns Nil and an error.
+func NewV7FromReader(r io.Reader) (UUID, error) {
+        uuid, err := NewRandomFromReader(r)
+        if err != nil {
+                return uuid, err
+        }
+
+        makeV7(uuid[:])
+        return uuid, nil
+}
+
+// makeV7 fill 48 bits time (uuid[0] - uuid[5]), set version b0111 (uuid[6])
+// uuid[8] already has the right version number (Variant is 10)
+// see function  NewV7 and NewV7FromReader
+func makeV7(uuid []byte) {
+        /*
+                 0                   1                   2                   3
+                 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+                +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+                |                           unix_ts_ms                          |
+                +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+                |          unix_ts_ms           |  ver  |       rand_a          |
+                +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+                |var|                        rand_b                             |
+                +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+                |                            rand_b                             |
+                +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+        */
+        _ = uuid[15] // bounds check
+
+        t := timeNow().UnixMilli()
+
+        uuid[0] = byte(t >> 40)
+        uuid[1] = byte(t >> 32)
+        uuid[2] = byte(t >> 24)
+        uuid[3] = byte(t >> 16)
+        uuid[4] = byte(t >> 8)
+        uuid[5] = byte(t)
+
+        uuid[6] = 0x70 | (uuid[6] & 0x0F)
+        // uuid[8] has already has right version
+}
diff --git a/vendor/github.com/json-iterator/go/.codecov.yml b/vendor/github.com/json-iterator/go/.codecov.yml
new file mode 100644
index 0000000..955dc0b
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/.codecov.yml
@@ -0,0 +1,3 @@
+ignore:
+    - "output_tests/.*"
+
diff --git a/vendor/github.com/json-iterator/go/.gitignore b/vendor/github.com/json-iterator/go/.gitignore
new file mode 100644
index 0000000..1555653
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/.gitignore
@@ -0,0 +1,4 @@
+/vendor
+/bug_test.go
+/coverage.txt
+/.idea
diff --git a/vendor/github.com/json-iterator/go/.travis.yml b/vendor/github.com/json-iterator/go/.travis.yml
new file mode 100644
index 0000000..449e67c
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/.travis.yml
@@ -0,0 +1,14 @@
+language: go
+
+go:
+  - 1.8.x
+  - 1.x
+
+before_install:
+  - go get -t -v ./...
+
+script:
+  - ./test.sh
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)
diff --git a/vendor/github.com/json-iterator/go/Gopkg.lock b/vendor/github.com/json-iterator/go/Gopkg.lock
new file mode 100644
index 0000000..c8a9fbb
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/Gopkg.lock
@@ -0,0 +1,21 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  name = "github.com/modern-go/concurrent"
+  packages = ["."]
+  revision = "e0a39a4cb4216ea8db28e22a69f4ec25610d513a"
+  version = "1.0.0"
+
+[[projects]]
+  name = "github.com/modern-go/reflect2"
+  packages = ["."]
+  revision = "4b7aa43c6742a2c18fdef89dd197aaae7dac7ccd"
+  version = "1.0.1"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  inputs-digest = "ea54a775e5a354cb015502d2e7aa4b74230fc77e894f34a838b268c25ec8eeb8"
+  solver-name = "gps-cdcl"
+  solver-version = 1
diff --git a/vendor/github.com/json-iterator/go/Gopkg.toml b/vendor/github.com/json-iterator/go/Gopkg.toml
new file mode 100644
index 0000000..313a0f8
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/Gopkg.toml
@@ -0,0 +1,26 @@
+# Gopkg.toml example
+#
+# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#  name = "github.com/x/y"
+#  version = "2.4.0"
+
+ignored = ["github.com/davecgh/go-spew*","github.com/google/gofuzz*","github.com/stretchr/testify*"]
+
+[[constraint]]
+  name = "github.com/modern-go/reflect2"
+  version = "1.0.1"
diff --git a/vendor/github.com/json-iterator/go/LICENSE b/vendor/github.com/json-iterator/go/LICENSE
new file mode 100644
index 0000000..2cf4f5a
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 json-iterator
+
+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.
diff --git a/vendor/github.com/json-iterator/go/README.md b/vendor/github.com/json-iterator/go/README.md
new file mode 100644
index 0000000..c589add
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/README.md
@@ -0,0 +1,85 @@
+[![Sourcegraph](https://sourcegraph.com/github.com/json-iterator/go/-/badge.svg)](https://sourcegraph.com/github.com/json-iterator/go?badge)
+[![GoDoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](https://pkg.go.dev/github.com/json-iterator/go)
+[![Build Status](https://travis-ci.org/json-iterator/go.svg?branch=master)](https://travis-ci.org/json-iterator/go)
+[![codecov](https://codecov.io/gh/json-iterator/go/branch/master/graph/badge.svg)](https://codecov.io/gh/json-iterator/go)
+[![rcard](https://goreportcard.com/badge/github.com/json-iterator/go)](https://goreportcard.com/report/github.com/json-iterator/go)
+[![License](http://img.shields.io/badge/license-mit-blue.svg?style=flat-square)](https://raw.githubusercontent.com/json-iterator/go/master/LICENSE)
+[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/json-iterator/Lobby)
+
+A high-performance 100% compatible drop-in replacement of "encoding/json"
+
+# Benchmark
+
+![benchmark](http://jsoniter.com/benchmarks/go-benchmark.png)
+
+Source code: https://github.com/json-iterator/go-benchmark/blob/master/src/github.com/json-iterator/go-benchmark/benchmark_medium_payload_test.go
+
+Raw Result (easyjson requires static code generation)
+
+|                 | ns/op       | allocation bytes | allocation times |
+| --------------- | ----------- | ---------------- | ---------------- |
+| std decode      | 35510 ns/op | 1960 B/op        | 99 allocs/op     |
+| easyjson decode | 8499 ns/op  | 160 B/op         | 4 allocs/op      |
+| jsoniter decode | 5623 ns/op  | 160 B/op         | 3 allocs/op      |
+| std encode      | 2213 ns/op  | 712 B/op         | 5 allocs/op      |
+| easyjson encode | 883 ns/op   | 576 B/op         | 3 allocs/op      |
+| jsoniter encode | 837 ns/op   | 384 B/op         | 4 allocs/op      |
+
+Always benchmark with your own workload.
+The result depends heavily on the data input.
+
+# Usage
+
+100% compatibility with standard lib
+
+Replace
+
+```go
+import "encoding/json"
+json.Marshal(&data)
+```
+
+with
+
+```go
+import jsoniter "github.com/json-iterator/go"
+
+var json = jsoniter.ConfigCompatibleWithStandardLibrary
+json.Marshal(&data)
+```
+
+Replace
+
+```go
+import "encoding/json"
+json.Unmarshal(input, &data)
+```
+
+with
+
+```go
+import jsoniter "github.com/json-iterator/go"
+
+var json = jsoniter.ConfigCompatibleWithStandardLibrary
+json.Unmarshal(input, &data)
+```
+
+[More documentation](http://jsoniter.com/migrate-from-go-std.html)
+
+# How to get
+
+```
+go get github.com/json-iterator/go
+```
+
+# Contribution Welcomed !
+
+Contributors
+
+- [thockin](https://github.com/thockin)
+- [mattn](https://github.com/mattn)
+- [cch123](https://github.com/cch123)
+- [Oleg Shaldybin](https://github.com/olegshaldybin)
+- [Jason Toffaletti](https://github.com/toffaletti)
+
+Report issue or pull request, or email [email protected], or [![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/json-iterator/Lobby)
diff --git a/vendor/github.com/json-iterator/go/adapter.go b/vendor/github.com/json-iterator/go/adapter.go
new file mode 100644
index 0000000..92d2cc4
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/adapter.go
@@ -0,0 +1,150 @@
+package jsoniter
+
+import (
+        "bytes"
+        "io"
+)
+
+// RawMessage to make replace json with jsoniter
+type RawMessage []byte
+
+// Unmarshal adapts to json/encoding Unmarshal API
+//
+// Unmarshal parses the JSON-encoded data and stores the result in the value pointed to by v.
+// Refer to https://godoc.org/encoding/json#Unmarshal for more information
+func Unmarshal(data []byte, v interface{}) error {
+        return ConfigDefault.Unmarshal(data, v)
+}
+
+// UnmarshalFromString is a convenient method to read from string instead of []byte
+func UnmarshalFromString(str string, v interface{}) error {
+        return ConfigDefault.UnmarshalFromString(str, v)
+}
+
+// Get quick method to get value from deeply nested JSON structure
+func Get(data []byte, path ...interface{}) Any {
+        return ConfigDefault.Get(data, path...)
+}
+
+// Marshal adapts to json/encoding Marshal API
+//
+// Marshal returns the JSON encoding of v, adapts to json/encoding Marshal API
+// Refer to https://godoc.org/encoding/json#Marshal for more information
+func Marshal(v interface{}) ([]byte, error) {
+        return ConfigDefault.Marshal(v)
+}
+
+// MarshalIndent same as json.MarshalIndent. Prefix is not supported.
+func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
+        return ConfigDefault.MarshalIndent(v, prefix, indent)
+}
+
+// MarshalToString convenient method to write as string instead of []byte
+func MarshalToString(v interface{}) (string, error) {
+        return ConfigDefault.MarshalToString(v)
+}
+
+// NewDecoder adapts to json/stream NewDecoder API.
+//
+// NewDecoder returns a new decoder that reads from r.
+//
+// Instead of a json/encoding Decoder, an Decoder is returned
+// Refer to https://godoc.org/encoding/json#NewDecoder for more information
+func NewDecoder(reader io.Reader) *Decoder {
+        return ConfigDefault.NewDecoder(reader)
+}
+
+// Decoder reads and decodes JSON values from an input stream.
+// Decoder provides identical APIs with json/stream Decoder (Token() and UseNumber() are in progress)
+type Decoder struct {
+        iter *Iterator
+}
+
+// Decode decode JSON into interface{}
+func (adapter *Decoder) Decode(obj interface{}) error {
+        if adapter.iter.head == adapter.iter.tail && adapter.iter.reader != nil {
+                if !adapter.iter.loadMore() {
+                        return io.EOF
+                }
+        }
+        adapter.iter.ReadVal(obj)
+        err := adapter.iter.Error
+        if err == io.EOF {
+                return nil
+        }
+        return adapter.iter.Error
+}
+
+// More is there more?
+func (adapter *Decoder) More() bool {
+        iter := adapter.iter
+        if iter.Error != nil {
+                return false
+        }
+        c := iter.nextToken()
+        if c == 0 {
+                return false
+        }
+        iter.unreadByte()
+        return c != ']' && c != '}'
+}
+
+// Buffered remaining buffer
+func (adapter *Decoder) Buffered() io.Reader {
+        remaining := adapter.iter.buf[adapter.iter.head:adapter.iter.tail]
+        return bytes.NewReader(remaining)
+}
+
+// UseNumber causes the Decoder to unmarshal a number into an interface{} as a
+// Number instead of as a float64.
+func (adapter *Decoder) UseNumber() {
+        cfg := adapter.iter.cfg.configBeforeFrozen
+        cfg.UseNumber = true
+        adapter.iter.cfg = cfg.frozeWithCacheReuse(adapter.iter.cfg.extraExtensions)
+}
+
+// DisallowUnknownFields causes the Decoder to return an error when the destination
+// is a struct and the input contains object keys which do not match any
+// non-ignored, exported fields in the destination.
+func (adapter *Decoder) DisallowUnknownFields() {
+        cfg := adapter.iter.cfg.configBeforeFrozen
+        cfg.DisallowUnknownFields = true
+        adapter.iter.cfg = cfg.frozeWithCacheReuse(adapter.iter.cfg.extraExtensions)
+}
+
+// NewEncoder same as json.NewEncoder
+func NewEncoder(writer io.Writer) *Encoder {
+        return ConfigDefault.NewEncoder(writer)
+}
+
+// Encoder same as json.Encoder
+type Encoder struct {
+        stream *Stream
+}
+
+// Encode encode interface{} as JSON to io.Writer
+func (adapter *Encoder) Encode(val interface{}) error {
+        adapter.stream.WriteVal(val)
+        adapter.stream.WriteRaw("\n")
+        adapter.stream.Flush()
+        return adapter.stream.Error
+}
+
+// SetIndent set the indention. Prefix is not supported
+func (adapter *Encoder) SetIndent(prefix, indent string) {
+        config := adapter.stream.cfg.configBeforeFrozen
+        config.IndentionStep = len(indent)
+        adapter.stream.cfg = config.frozeWithCacheReuse(adapter.stream.cfg.extraExtensions)
+}
+
+// SetEscapeHTML escape html by default, set to false to disable
+func (adapter *Encoder) SetEscapeHTML(escapeHTML bool) {
+        config := adapter.stream.cfg.configBeforeFrozen
+        config.EscapeHTML = escapeHTML
+        adapter.stream.cfg = config.frozeWithCacheReuse(adapter.stream.cfg.extraExtensions)
+}
+
+// Valid reports whether data is a valid JSON encoding.
+func Valid(data []byte) bool {
+        return ConfigDefault.Valid(data)
+}
diff --git a/vendor/github.com/json-iterator/go/any.go b/vendor/github.com/json-iterator/go/any.go
new file mode 100644
index 0000000..f6b8aea
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any.go
@@ -0,0 +1,325 @@
+package jsoniter
+
+import (
+        "errors"
+        "fmt"
+        "github.com/modern-go/reflect2"
+        "io"
+        "reflect"
+        "strconv"
+        "unsafe"
+)
+
+// Any generic object representation.
+// The lazy json implementation holds []byte and parse lazily.
+type Any interface {
+        LastError() error
+        ValueType() ValueType
+        MustBeValid() Any
+        ToBool() bool
+        ToInt() int
+        ToInt32() int32
+        ToInt64() int64
+        ToUint() uint
+        ToUint32() uint32
+        ToUint64() uint64
+        ToFloat32() float32
+        ToFloat64() float64
+        ToString() string
+        ToVal(val interface{})
+        Get(path ...interface{}) Any
+        Size() int
+        Keys() []string
+        GetInterface() interface{}
+        WriteTo(stream *Stream)
+}
+
+type baseAny struct{}
+
+func (any *baseAny) Get(path ...interface{}) Any {
+        return &invalidAny{baseAny{}, fmt.Errorf("GetIndex %v from simple value", path)}
+}
+
+func (any *baseAny) Size() int {
+        return 0
+}
+
+func (any *baseAny) Keys() []string {
+        return []string{}
+}
+
+func (any *baseAny) ToVal(obj interface{}) {
+        panic("not implemented")
+}
+
+// WrapInt32 turn int32 into Any interface
+func WrapInt32(val int32) Any {
+        return &int32Any{baseAny{}, val}
+}
+
+// WrapInt64 turn int64 into Any interface
+func WrapInt64(val int64) Any {
+        return &int64Any{baseAny{}, val}
+}
+
+// WrapUint32 turn uint32 into Any interface
+func WrapUint32(val uint32) Any {
+        return &uint32Any{baseAny{}, val}
+}
+
+// WrapUint64 turn uint64 into Any interface
+func WrapUint64(val uint64) Any {
+        return &uint64Any{baseAny{}, val}
+}
+
+// WrapFloat64 turn float64 into Any interface
+func WrapFloat64(val float64) Any {
+        return &floatAny{baseAny{}, val}
+}
+
+// WrapString turn string into Any interface
+func WrapString(val string) Any {
+        return &stringAny{baseAny{}, val}
+}
+
+// Wrap turn a go object into Any interface
+func Wrap(val interface{}) Any {
+        if val == nil {
+                return &nilAny{}
+        }
+        asAny, isAny := val.(Any)
+        if isAny {
+                return asAny
+        }
+        typ := reflect2.TypeOf(val)
+        switch typ.Kind() {
+        case reflect.Slice:
+                return wrapArray(val)
+        case reflect.Struct:
+                return wrapStruct(val)
+        case reflect.Map:
+                return wrapMap(val)
+        case reflect.String:
+                return WrapString(val.(string))
+        case reflect.Int:
+                if strconv.IntSize == 32 {
+                        return WrapInt32(int32(val.(int)))
+                }
+                return WrapInt64(int64(val.(int)))
+        case reflect.Int8:
+                return WrapInt32(int32(val.(int8)))
+        case reflect.Int16:
+                return WrapInt32(int32(val.(int16)))
+        case reflect.Int32:
+                return WrapInt32(val.(int32))
+        case reflect.Int64:
+                return WrapInt64(val.(int64))
+        case reflect.Uint:
+                if strconv.IntSize == 32 {
+                        return WrapUint32(uint32(val.(uint)))
+                }
+                return WrapUint64(uint64(val.(uint)))
+        case reflect.Uintptr:
+                if ptrSize == 32 {
+                        return WrapUint32(uint32(val.(uintptr)))
+                }
+                return WrapUint64(uint64(val.(uintptr)))
+        case reflect.Uint8:
+                return WrapUint32(uint32(val.(uint8)))
+        case reflect.Uint16:
+                return WrapUint32(uint32(val.(uint16)))
+        case reflect.Uint32:
+                return WrapUint32(uint32(val.(uint32)))
+        case reflect.Uint64:
+                return WrapUint64(val.(uint64))
+        case reflect.Float32:
+                return WrapFloat64(float64(val.(float32)))
+        case reflect.Float64:
+                return WrapFloat64(val.(float64))
+        case reflect.Bool:
+                if val.(bool) == true {
+                        return &trueAny{}
+                }
+                return &falseAny{}
+        }
+        return &invalidAny{baseAny{}, fmt.Errorf("unsupported type: %v", typ)}
+}
+
+// ReadAny read next JSON element as an Any object. It is a better json.RawMessage.
+func (iter *Iterator) ReadAny() Any {
+        return iter.readAny()
+}
+
+func (iter *Iterator) readAny() Any {
+        c := iter.nextToken()
+        switch c {
+        case '"':
+                iter.unreadByte()
+                return &stringAny{baseAny{}, iter.ReadString()}
+        case 'n':
+                iter.skipThreeBytes('u', 'l', 'l') // null
+                return &nilAny{}
+        case 't':
+                iter.skipThreeBytes('r', 'u', 'e') // true
+                return &trueAny{}
+        case 'f':
+                iter.skipFourBytes('a', 'l', 's', 'e') // false
+                return &falseAny{}
+        case '{':
+                return iter.readObjectAny()
+        case '[':
+                return iter.readArrayAny()
+        case '-':
+                return iter.readNumberAny(false)
+        case 0:
+                return &invalidAny{baseAny{}, errors.New("input is empty")}
+        default:
+                return iter.readNumberAny(true)
+        }
+}
+
+func (iter *Iterator) readNumberAny(positive bool) Any {
+        iter.startCapture(iter.head - 1)
+        iter.skipNumber()
+        lazyBuf := iter.stopCapture()
+        return &numberLazyAny{baseAny{}, iter.cfg, lazyBuf, nil}
+}
+
+func (iter *Iterator) readObjectAny() Any {
+        iter.startCapture(iter.head - 1)
+        iter.skipObject()
+        lazyBuf := iter.stopCapture()
+        return &objectLazyAny{baseAny{}, iter.cfg, lazyBuf, nil}
+}
+
+func (iter *Iterator) readArrayAny() Any {
+        iter.startCapture(iter.head - 1)
+        iter.skipArray()
+        lazyBuf := iter.stopCapture()
+        return &arrayLazyAny{baseAny{}, iter.cfg, lazyBuf, nil}
+}
+
+func locateObjectField(iter *Iterator, target string) []byte {
+        var found []byte
+        iter.ReadObjectCB(func(iter *Iterator, field string) bool {
+                if field == target {
+                        found = iter.SkipAndReturnBytes()
+                        return false
+                }
+                iter.Skip()
+                return true
+        })
+        return found
+}
+
+func locateArrayElement(iter *Iterator, target int) []byte {
+        var found []byte
+        n := 0
+        iter.ReadArrayCB(func(iter *Iterator) bool {
+                if n == target {
+                        found = iter.SkipAndReturnBytes()
+                        return false
+                }
+                iter.Skip()
+                n++
+                return true
+        })
+        return found
+}
+
+func locatePath(iter *Iterator, path []interface{}) Any {
+        for i, pathKeyObj := range path {
+                switch pathKey := pathKeyObj.(type) {
+                case string:
+                        valueBytes := locateObjectField(iter, pathKey)
+                        if valueBytes == nil {
+                                return newInvalidAny(path[i:])
+                        }
+                        iter.ResetBytes(valueBytes)
+                case int:
+                        valueBytes := locateArrayElement(iter, pathKey)
+                        if valueBytes == nil {
+                                return newInvalidAny(path[i:])
+                        }
+                        iter.ResetBytes(valueBytes)
+                case int32:
+                        if '*' == pathKey {
+                                return iter.readAny().Get(path[i:]...)
+                        }
+                        return newInvalidAny(path[i:])
+                default:
+                        return newInvalidAny(path[i:])
+                }
+        }
+        if iter.Error != nil && iter.Error != io.EOF {
+                return &invalidAny{baseAny{}, iter.Error}
+        }
+        return iter.readAny()
+}
+
+var anyType = reflect2.TypeOfPtr((*Any)(nil)).Elem()
+
+func createDecoderOfAny(ctx *ctx, typ reflect2.Type) ValDecoder {
+        if typ == anyType {
+                return &directAnyCodec{}
+        }
+        if typ.Implements(anyType) {
+                return &anyCodec{
+                        valType: typ,
+                }
+        }
+        return nil
+}
+
+func createEncoderOfAny(ctx *ctx, typ reflect2.Type) ValEncoder {
+        if typ == anyType {
+                return &directAnyCodec{}
+        }
+        if typ.Implements(anyType) {
+                return &anyCodec{
+                        valType: typ,
+                }
+        }
+        return nil
+}
+
+type anyCodec struct {
+        valType reflect2.Type
+}
+
+func (codec *anyCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        panic("not implemented")
+}
+
+func (codec *anyCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        obj := codec.valType.UnsafeIndirect(ptr)
+        any := obj.(Any)
+        any.WriteTo(stream)
+}
+
+func (codec *anyCodec) IsEmpty(ptr unsafe.Pointer) bool {
+        obj := codec.valType.UnsafeIndirect(ptr)
+        any := obj.(Any)
+        return any.Size() == 0
+}
+
+type directAnyCodec struct {
+}
+
+func (codec *directAnyCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        *(*Any)(ptr) = iter.readAny()
+}
+
+func (codec *directAnyCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        any := *(*Any)(ptr)
+        if any == nil {
+                stream.WriteNil()
+                return
+        }
+        any.WriteTo(stream)
+}
+
+func (codec *directAnyCodec) IsEmpty(ptr unsafe.Pointer) bool {
+        any := *(*Any)(ptr)
+        return any.Size() == 0
+}
diff --git a/vendor/github.com/json-iterator/go/any_array.go b/vendor/github.com/json-iterator/go/any_array.go
new file mode 100644
index 0000000..0449e9a
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_array.go
@@ -0,0 +1,278 @@
+package jsoniter
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type arrayLazyAny struct {
+        baseAny
+        cfg *frozenConfig
+        buf []byte
+        err error
+}
+
+func (any *arrayLazyAny) ValueType() ValueType {
+        return ArrayValue
+}
+
+func (any *arrayLazyAny) MustBeValid() Any {
+        return any
+}
+
+func (any *arrayLazyAny) LastError() error {
+        return any.err
+}
+
+func (any *arrayLazyAny) ToBool() bool {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        return iter.ReadArray()
+}
+
+func (any *arrayLazyAny) ToInt() int {
+        if any.ToBool() {
+                return 1
+        }
+        return 0
+}
+
+func (any *arrayLazyAny) ToInt32() int32 {
+        if any.ToBool() {
+                return 1
+        }
+        return 0
+}
+
+func (any *arrayLazyAny) ToInt64() int64 {
+        if any.ToBool() {
+                return 1
+        }
+        return 0
+}
+
+func (any *arrayLazyAny) ToUint() uint {
+        if any.ToBool() {
+                return 1
+        }
+        return 0
+}
+
+func (any *arrayLazyAny) ToUint32() uint32 {
+        if any.ToBool() {
+                return 1
+        }
+        return 0
+}
+
+func (any *arrayLazyAny) ToUint64() uint64 {
+        if any.ToBool() {
+                return 1
+        }
+        return 0
+}
+
+func (any *arrayLazyAny) ToFloat32() float32 {
+        if any.ToBool() {
+                return 1
+        }
+        return 0
+}
+
+func (any *arrayLazyAny) ToFloat64() float64 {
+        if any.ToBool() {
+                return 1
+        }
+        return 0
+}
+
+func (any *arrayLazyAny) ToString() string {
+        return *(*string)(unsafe.Pointer(&any.buf))
+}
+
+func (any *arrayLazyAny) ToVal(val interface{}) {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        iter.ReadVal(val)
+}
+
+func (any *arrayLazyAny) Get(path ...interface{}) Any {
+        if len(path) == 0 {
+                return any
+        }
+        switch firstPath := path[0].(type) {
+        case int:
+                iter := any.cfg.BorrowIterator(any.buf)
+                defer any.cfg.ReturnIterator(iter)
+                valueBytes := locateArrayElement(iter, firstPath)
+                if valueBytes == nil {
+                        return newInvalidAny(path)
+                }
+                iter.ResetBytes(valueBytes)
+                return locatePath(iter, path[1:])
+        case int32:
+                if '*' == firstPath {
+                        iter := any.cfg.BorrowIterator(any.buf)
+                        defer any.cfg.ReturnIterator(iter)
+                        arr := make([]Any, 0)
+                        iter.ReadArrayCB(func(iter *Iterator) bool {
+                                found := iter.readAny().Get(path[1:]...)
+                                if found.ValueType() != InvalidValue {
+                                        arr = append(arr, found)
+                                }
+                                return true
+                        })
+                        return wrapArray(arr)
+                }
+                return newInvalidAny(path)
+        default:
+                return newInvalidAny(path)
+        }
+}
+
+func (any *arrayLazyAny) Size() int {
+        size := 0
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        iter.ReadArrayCB(func(iter *Iterator) bool {
+                size++
+                iter.Skip()
+                return true
+        })
+        return size
+}
+
+func (any *arrayLazyAny) WriteTo(stream *Stream) {
+        stream.Write(any.buf)
+}
+
+func (any *arrayLazyAny) GetInterface() interface{} {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        return iter.Read()
+}
+
+type arrayAny struct {
+        baseAny
+        val reflect.Value
+}
+
+func wrapArray(val interface{}) *arrayAny {
+        return &arrayAny{baseAny{}, reflect.ValueOf(val)}
+}
+
+func (any *arrayAny) ValueType() ValueType {
+        return ArrayValue
+}
+
+func (any *arrayAny) MustBeValid() Any {
+        return any
+}
+
+func (any *arrayAny) LastError() error {
+        return nil
+}
+
+func (any *arrayAny) ToBool() bool {
+        return any.val.Len() != 0
+}
+
+func (any *arrayAny) ToInt() int {
+        if any.val.Len() == 0 {
+                return 0
+        }
+        return 1
+}
+
+func (any *arrayAny) ToInt32() int32 {
+        if any.val.Len() == 0 {
+                return 0
+        }
+        return 1
+}
+
+func (any *arrayAny) ToInt64() int64 {
+        if any.val.Len() == 0 {
+                return 0
+        }
+        return 1
+}
+
+func (any *arrayAny) ToUint() uint {
+        if any.val.Len() == 0 {
+                return 0
+        }
+        return 1
+}
+
+func (any *arrayAny) ToUint32() uint32 {
+        if any.val.Len() == 0 {
+                return 0
+        }
+        return 1
+}
+
+func (any *arrayAny) ToUint64() uint64 {
+        if any.val.Len() == 0 {
+                return 0
+        }
+        return 1
+}
+
+func (any *arrayAny) ToFloat32() float32 {
+        if any.val.Len() == 0 {
+                return 0
+        }
+        return 1
+}
+
+func (any *arrayAny) ToFloat64() float64 {
+        if any.val.Len() == 0 {
+                return 0
+        }
+        return 1
+}
+
+func (any *arrayAny) ToString() string {
+        str, _ := MarshalToString(any.val.Interface())
+        return str
+}
+
+func (any *arrayAny) Get(path ...interface{}) Any {
+        if len(path) == 0 {
+                return any
+        }
+        switch firstPath := path[0].(type) {
+        case int:
+                if firstPath < 0 || firstPath >= any.val.Len() {
+                        return newInvalidAny(path)
+                }
+                return Wrap(any.val.Index(firstPath).Interface())
+        case int32:
+                if '*' == firstPath {
+                        mappedAll := make([]Any, 0)
+                        for i := 0; i < any.val.Len(); i++ {
+                                mapped := Wrap(any.val.Index(i).Interface()).Get(path[1:]...)
+                                if mapped.ValueType() != InvalidValue {
+                                        mappedAll = append(mappedAll, mapped)
+                                }
+                        }
+                        return wrapArray(mappedAll)
+                }
+                return newInvalidAny(path)
+        default:
+                return newInvalidAny(path)
+        }
+}
+
+func (any *arrayAny) Size() int {
+        return any.val.Len()
+}
+
+func (any *arrayAny) WriteTo(stream *Stream) {
+        stream.WriteVal(any.val)
+}
+
+func (any *arrayAny) GetInterface() interface{} {
+        return any.val.Interface()
+}
diff --git a/vendor/github.com/json-iterator/go/any_bool.go b/vendor/github.com/json-iterator/go/any_bool.go
new file mode 100644
index 0000000..9452324
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_bool.go
@@ -0,0 +1,137 @@
+package jsoniter
+
+type trueAny struct {
+        baseAny
+}
+
+func (any *trueAny) LastError() error {
+        return nil
+}
+
+func (any *trueAny) ToBool() bool {
+        return true
+}
+
+func (any *trueAny) ToInt() int {
+        return 1
+}
+
+func (any *trueAny) ToInt32() int32 {
+        return 1
+}
+
+func (any *trueAny) ToInt64() int64 {
+        return 1
+}
+
+func (any *trueAny) ToUint() uint {
+        return 1
+}
+
+func (any *trueAny) ToUint32() uint32 {
+        return 1
+}
+
+func (any *trueAny) ToUint64() uint64 {
+        return 1
+}
+
+func (any *trueAny) ToFloat32() float32 {
+        return 1
+}
+
+func (any *trueAny) ToFloat64() float64 {
+        return 1
+}
+
+func (any *trueAny) ToString() string {
+        return "true"
+}
+
+func (any *trueAny) WriteTo(stream *Stream) {
+        stream.WriteTrue()
+}
+
+func (any *trueAny) Parse() *Iterator {
+        return nil
+}
+
+func (any *trueAny) GetInterface() interface{} {
+        return true
+}
+
+func (any *trueAny) ValueType() ValueType {
+        return BoolValue
+}
+
+func (any *trueAny) MustBeValid() Any {
+        return any
+}
+
+type falseAny struct {
+        baseAny
+}
+
+func (any *falseAny) LastError() error {
+        return nil
+}
+
+func (any *falseAny) ToBool() bool {
+        return false
+}
+
+func (any *falseAny) ToInt() int {
+        return 0
+}
+
+func (any *falseAny) ToInt32() int32 {
+        return 0
+}
+
+func (any *falseAny) ToInt64() int64 {
+        return 0
+}
+
+func (any *falseAny) ToUint() uint {
+        return 0
+}
+
+func (any *falseAny) ToUint32() uint32 {
+        return 0
+}
+
+func (any *falseAny) ToUint64() uint64 {
+        return 0
+}
+
+func (any *falseAny) ToFloat32() float32 {
+        return 0
+}
+
+func (any *falseAny) ToFloat64() float64 {
+        return 0
+}
+
+func (any *falseAny) ToString() string {
+        return "false"
+}
+
+func (any *falseAny) WriteTo(stream *Stream) {
+        stream.WriteFalse()
+}
+
+func (any *falseAny) Parse() *Iterator {
+        return nil
+}
+
+func (any *falseAny) GetInterface() interface{} {
+        return false
+}
+
+func (any *falseAny) ValueType() ValueType {
+        return BoolValue
+}
+
+func (any *falseAny) MustBeValid() Any {
+        return any
+}
diff --git a/vendor/github.com/json-iterator/go/any_float.go b/vendor/github.com/json-iterator/go/any_float.go
new file mode 100644
index 0000000..35fdb09
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_float.go
@@ -0,0 +1,83 @@
+package jsoniter
+
+import (
+        "strconv"
+)
+
+type floatAny struct {
+        baseAny
+        val float64
+}
+
+func (any *floatAny) Parse() *Iterator {
+        return nil
+}
+
+func (any *floatAny) ValueType() ValueType {
+        return NumberValue
+}
+
+func (any *floatAny) MustBeValid() Any {
+        return any
+}
+
+func (any *floatAny) LastError() error {
+        return nil
+}
+
+func (any *floatAny) ToBool() bool {
+        return any.ToFloat64() != 0
+}
+
+func (any *floatAny) ToInt() int {
+        return int(any.val)
+}
+
+func (any *floatAny) ToInt32() int32 {
+        return int32(any.val)
+}
+
+func (any *floatAny) ToInt64() int64 {
+        return int64(any.val)
+}
+
+func (any *floatAny) ToUint() uint {
+        if any.val > 0 {
+                return uint(any.val)
+        }
+        return 0
+}
+
+func (any *floatAny) ToUint32() uint32 {
+        if any.val > 0 {
+                return uint32(any.val)
+        }
+        return 0
+}
+
+func (any *floatAny) ToUint64() uint64 {
+        if any.val > 0 {
+                return uint64(any.val)
+        }
+        return 0
+}
+
+func (any *floatAny) ToFloat32() float32 {
+        return float32(any.val)
+}
+
+func (any *floatAny) ToFloat64() float64 {
+        return any.val
+}
+
+func (any *floatAny) ToString() string {
+        return strconv.FormatFloat(any.val, 'E', -1, 64)
+}
+
+func (any *floatAny) WriteTo(stream *Stream) {
+        stream.WriteFloat64(any.val)
+}
+
+func (any *floatAny) GetInterface() interface{} {
+        return any.val
+}
diff --git a/vendor/github.com/json-iterator/go/any_int32.go b/vendor/github.com/json-iterator/go/any_int32.go
new file mode 100644
index 0000000..1b56f39
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_int32.go
@@ -0,0 +1,74 @@
+package jsoniter
+
+import (
+        "strconv"
+)
+
+type int32Any struct {
+        baseAny
+        val int32
+}
+
+func (any *int32Any) LastError() error {
+        return nil
+}
+
+func (any *int32Any) ValueType() ValueType {
+        return NumberValue
+}
+
+func (any *int32Any) MustBeValid() Any {
+        return any
+}
+
+func (any *int32Any) ToBool() bool {
+        return any.val != 0
+}
+
+func (any *int32Any) ToInt() int {
+        return int(any.val)
+}
+
+func (any *int32Any) ToInt32() int32 {
+        return any.val
+}
+
+func (any *int32Any) ToInt64() int64 {
+        return int64(any.val)
+}
+
+func (any *int32Any) ToUint() uint {
+        return uint(any.val)
+}
+
+func (any *int32Any) ToUint32() uint32 {
+        return uint32(any.val)
+}
+
+func (any *int32Any) ToUint64() uint64 {
+        return uint64(any.val)
+}
+
+func (any *int32Any) ToFloat32() float32 {
+        return float32(any.val)
+}
+
+func (any *int32Any) ToFloat64() float64 {
+        return float64(any.val)
+}
+
+func (any *int32Any) ToString() string {
+        return strconv.FormatInt(int64(any.val), 10)
+}
+
+func (any *int32Any) WriteTo(stream *Stream) {
+        stream.WriteInt32(any.val)
+}
+
+func (any *int32Any) Parse() *Iterator {
+        return nil
+}
+
+func (any *int32Any) GetInterface() interface{} {
+        return any.val
+}
diff --git a/vendor/github.com/json-iterator/go/any_int64.go b/vendor/github.com/json-iterator/go/any_int64.go
new file mode 100644
index 0000000..c440d72
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_int64.go
@@ -0,0 +1,74 @@
+package jsoniter
+
+import (
+        "strconv"
+)
+
+type int64Any struct {
+        baseAny
+        val int64
+}
+
+func (any *int64Any) LastError() error {
+        return nil
+}
+
+func (any *int64Any) ValueType() ValueType {
+        return NumberValue
+}
+
+func (any *int64Any) MustBeValid() Any {
+        return any
+}
+
+func (any *int64Any) ToBool() bool {
+        return any.val != 0
+}
+
+func (any *int64Any) ToInt() int {
+        return int(any.val)
+}
+
+func (any *int64Any) ToInt32() int32 {
+        return int32(any.val)
+}
+
+func (any *int64Any) ToInt64() int64 {
+        return any.val
+}
+
+func (any *int64Any) ToUint() uint {
+        return uint(any.val)
+}
+
+func (any *int64Any) ToUint32() uint32 {
+        return uint32(any.val)
+}
+
+func (any *int64Any) ToUint64() uint64 {
+        return uint64(any.val)
+}
+
+func (any *int64Any) ToFloat32() float32 {
+        return float32(any.val)
+}
+
+func (any *int64Any) ToFloat64() float64 {
+        return float64(any.val)
+}
+
+func (any *int64Any) ToString() string {
+        return strconv.FormatInt(any.val, 10)
+}
+
+func (any *int64Any) WriteTo(stream *Stream) {
+        stream.WriteInt64(any.val)
+}
+
+func (any *int64Any) Parse() *Iterator {
+        return nil
+}
+
+func (any *int64Any) GetInterface() interface{} {
+        return any.val
+}
diff --git a/vendor/github.com/json-iterator/go/any_invalid.go b/vendor/github.com/json-iterator/go/any_invalid.go
new file mode 100644
index 0000000..1d859ea
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_invalid.go
@@ -0,0 +1,82 @@
+package jsoniter
+
+import "fmt"
+
+type invalidAny struct {
+        baseAny
+        err error
+}
+
+func newInvalidAny(path []interface{}) *invalidAny {
+        return &invalidAny{baseAny{}, fmt.Errorf("%v not found", path)}
+}
+
+func (any *invalidAny) LastError() error {
+        return any.err
+}
+
+func (any *invalidAny) ValueType() ValueType {
+        return InvalidValue
+}
+
+func (any *invalidAny) MustBeValid() Any {
+        panic(any.err)
+}
+
+func (any *invalidAny) ToBool() bool {
+        return false
+}
+
+func (any *invalidAny) ToInt() int {
+        return 0
+}
+
+func (any *invalidAny) ToInt32() int32 {
+        return 0
+}
+
+func (any *invalidAny) ToInt64() int64 {
+        return 0
+}
+
+func (any *invalidAny) ToUint() uint {
+        return 0
+}
+
+func (any *invalidAny) ToUint32() uint32 {
+        return 0
+}
+
+func (any *invalidAny) ToUint64() uint64 {
+        return 0
+}
+
+func (any *invalidAny) ToFloat32() float32 {
+        return 0
+}
+
+func (any *invalidAny) ToFloat64() float64 {
+        return 0
+}
+
+func (any *invalidAny) ToString() string {
+        return ""
+}
+
+func (any *invalidAny) WriteTo(stream *Stream) {
+}
+
+func (any *invalidAny) Get(path ...interface{}) Any {
+        if any.err == nil {
+                return &invalidAny{baseAny{}, fmt.Errorf("get %v from invalid", path)}
+        }
+        return &invalidAny{baseAny{}, fmt.Errorf("%v, get %v from invalid", any.err, path)}
+}
+
+func (any *invalidAny) Parse() *Iterator {
+        return nil
+}
+
+func (any *invalidAny) GetInterface() interface{} {
+        return nil
+}
diff --git a/vendor/github.com/json-iterator/go/any_nil.go b/vendor/github.com/json-iterator/go/any_nil.go
new file mode 100644
index 0000000..d04cb54
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_nil.go
@@ -0,0 +1,69 @@
+package jsoniter
+
+type nilAny struct {
+        baseAny
+}
+
+func (any *nilAny) LastError() error {
+        return nil
+}
+
+func (any *nilAny) ValueType() ValueType {
+        return NilValue
+}
+
+func (any *nilAny) MustBeValid() Any {
+        return any
+}
+
+func (any *nilAny) ToBool() bool {
+        return false
+}
+
+func (any *nilAny) ToInt() int {
+        return 0
+}
+
+func (any *nilAny) ToInt32() int32 {
+        return 0
+}
+
+func (any *nilAny) ToInt64() int64 {
+        return 0
+}
+
+func (any *nilAny) ToUint() uint {
+        return 0
+}
+
+func (any *nilAny) ToUint32() uint32 {
+        return 0
+}
+
+func (any *nilAny) ToUint64() uint64 {
+        return 0
+}
+
+func (any *nilAny) ToFloat32() float32 {
+        return 0
+}
+
+func (any *nilAny) ToFloat64() float64 {
+        return 0
+}
+
+func (any *nilAny) ToString() string {
+        return ""
+}
+
+func (any *nilAny) WriteTo(stream *Stream) {
+        stream.WriteNil()
+}
+
+func (any *nilAny) Parse() *Iterator {
+        return nil
+}
+
+func (any *nilAny) GetInterface() interface{} {
+        return nil
+}
diff --git a/vendor/github.com/json-iterator/go/any_number.go b/vendor/github.com/json-iterator/go/any_number.go
new file mode 100644
index 0000000..9d1e901
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_number.go
@@ -0,0 +1,123 @@
+package jsoniter
+
+import (
+        "io"
+        "unsafe"
+)
+
+type numberLazyAny struct {
+        baseAny
+        cfg *frozenConfig
+        buf []byte
+        err error
+}
+
+func (any *numberLazyAny) ValueType() ValueType {
+        return NumberValue
+}
+
+func (any *numberLazyAny) MustBeValid() Any {
+        return any
+}
+
+func (any *numberLazyAny) LastError() error {
+        return any.err
+}
+
+func (any *numberLazyAny) ToBool() bool {
+        return any.ToFloat64() != 0
+}
+
+func (any *numberLazyAny) ToInt() int {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        val := iter.ReadInt()
+        if iter.Error != nil && iter.Error != io.EOF {
+                any.err = iter.Error
+        }
+        return val
+}
+
+func (any *numberLazyAny) ToInt32() int32 {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        val := iter.ReadInt32()
+        if iter.Error != nil && iter.Error != io.EOF {
+                any.err = iter.Error
+        }
+        return val
+}
+
+func (any *numberLazyAny) ToInt64() int64 {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        val := iter.ReadInt64()
+        if iter.Error != nil && iter.Error != io.EOF {
+                any.err = iter.Error
+        }
+        return val
+}
+
+func (any *numberLazyAny) ToUint() uint {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        val := iter.ReadUint()
+        if iter.Error != nil && iter.Error != io.EOF {
+                any.err = iter.Error
+        }
+        return val
+}
+
+func (any *numberLazyAny) ToUint32() uint32 {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        val := iter.ReadUint32()
+        if iter.Error != nil && iter.Error != io.EOF {
+                any.err = iter.Error
+        }
+        return val
+}
+
+func (any *numberLazyAny) ToUint64() uint64 {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        val := iter.ReadUint64()
+        if iter.Error != nil && iter.Error != io.EOF {
+                any.err = iter.Error
+        }
+        return val
+}
+
+func (any *numberLazyAny) ToFloat32() float32 {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        val := iter.ReadFloat32()
+        if iter.Error != nil && iter.Error != io.EOF {
+                any.err = iter.Error
+        }
+        return val
+}
+
+func (any *numberLazyAny) ToFloat64() float64 {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        val := iter.ReadFloat64()
+        if iter.Error != nil && iter.Error != io.EOF {
+                any.err = iter.Error
+        }
+        return val
+}
+
+func (any *numberLazyAny) ToString() string {
+        return *(*string)(unsafe.Pointer(&any.buf))
+}
+
+func (any *numberLazyAny) WriteTo(stream *Stream) {
+        stream.Write(any.buf)
+}
+
+func (any *numberLazyAny) GetInterface() interface{} {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        return iter.Read()
+}
diff --git a/vendor/github.com/json-iterator/go/any_object.go b/vendor/github.com/json-iterator/go/any_object.go
new file mode 100644
index 0000000..c44ef5c
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_object.go
@@ -0,0 +1,374 @@
+package jsoniter
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type objectLazyAny struct {
+        baseAny
+        cfg *frozenConfig
+        buf []byte
+        err error
+}
+
+func (any *objectLazyAny) ValueType() ValueType {
+        return ObjectValue
+}
+
+func (any *objectLazyAny) MustBeValid() Any {
+        return any
+}
+
+func (any *objectLazyAny) LastError() error {
+        return any.err
+}
+
+func (any *objectLazyAny) ToBool() bool {
+        return true
+}
+
+func (any *objectLazyAny) ToInt() int {
+        return 0
+}
+
+func (any *objectLazyAny) ToInt32() int32 {
+        return 0
+}
+
+func (any *objectLazyAny) ToInt64() int64 {
+        return 0
+}
+
+func (any *objectLazyAny) ToUint() uint {
+        return 0
+}
+
+func (any *objectLazyAny) ToUint32() uint32 {
+        return 0
+}
+
+func (any *objectLazyAny) ToUint64() uint64 {
+        return 0
+}
+
+func (any *objectLazyAny) ToFloat32() float32 {
+        return 0
+}
+
+func (any *objectLazyAny) ToFloat64() float64 {
+        return 0
+}
+
+func (any *objectLazyAny) ToString() string {
+        return *(*string)(unsafe.Pointer(&any.buf))
+}
+
+func (any *objectLazyAny) ToVal(obj interface{}) {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        iter.ReadVal(obj)
+}
+
+func (any *objectLazyAny) Get(path ...interface{}) Any {
+        if len(path) == 0 {
+                return any
+        }
+        switch firstPath := path[0].(type) {
+        case string:
+                iter := any.cfg.BorrowIterator(any.buf)
+                defer any.cfg.ReturnIterator(iter)
+                valueBytes := locateObjectField(iter, firstPath)
+                if valueBytes == nil {
+                        return newInvalidAny(path)
+                }
+                iter.ResetBytes(valueBytes)
+                return locatePath(iter, path[1:])
+        case int32:
+                if '*' == firstPath {
+                        mappedAll := map[string]Any{}
+                        iter := any.cfg.BorrowIterator(any.buf)
+                        defer any.cfg.ReturnIterator(iter)
+                        iter.ReadMapCB(func(iter *Iterator, field string) bool {
+                                mapped := locatePath(iter, path[1:])
+                                if mapped.ValueType() != InvalidValue {
+                                        mappedAll[field] = mapped
+                                }
+                                return true
+                        })
+                        return wrapMap(mappedAll)
+                }
+                return newInvalidAny(path)
+        default:
+                return newInvalidAny(path)
+        }
+}
+
+func (any *objectLazyAny) Keys() []string {
+        keys := []string{}
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        iter.ReadMapCB(func(iter *Iterator, field string) bool {
+                iter.Skip()
+                keys = append(keys, field)
+                return true
+        })
+        return keys
+}
+
+func (any *objectLazyAny) Size() int {
+        size := 0
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        iter.ReadObjectCB(func(iter *Iterator, field string) bool {
+                iter.Skip()
+                size++
+                return true
+        })
+        return size
+}
+
+func (any *objectLazyAny) WriteTo(stream *Stream) {
+        stream.Write(any.buf)
+}
+
+func (any *objectLazyAny) GetInterface() interface{} {
+        iter := any.cfg.BorrowIterator(any.buf)
+        defer any.cfg.ReturnIterator(iter)
+        return iter.Read()
+}
+
+type objectAny struct {
+        baseAny
+        err error
+        val reflect.Value
+}
+
+func wrapStruct(val interface{}) *objectAny {
+        return &objectAny{baseAny{}, nil, reflect.ValueOf(val)}
+}
+
+func (any *objectAny) ValueType() ValueType {
+        return ObjectValue
+}
+
+func (any *objectAny) MustBeValid() Any {
+        return any
+}
+
+func (any *objectAny) Parse() *Iterator {
+        return nil
+}
+
+func (any *objectAny) LastError() error {
+        return any.err
+}
+
+func (any *objectAny) ToBool() bool {
+        return any.val.NumField() != 0
+}
+
+func (any *objectAny) ToInt() int {
+        return 0
+}
+
+func (any *objectAny) ToInt32() int32 {
+        return 0
+}
+
+func (any *objectAny) ToInt64() int64 {
+        return 0
+}
+
+func (any *objectAny) ToUint() uint {
+        return 0
+}
+
+func (any *objectAny) ToUint32() uint32 {
+        return 0
+}
+
+func (any *objectAny) ToUint64() uint64 {
+        return 0
+}
+
+func (any *objectAny) ToFloat32() float32 {
+        return 0
+}
+
+func (any *objectAny) ToFloat64() float64 {
+        return 0
+}
+
+func (any *objectAny) ToString() string {
+        str, err := MarshalToString(any.val.Interface())
+        any.err = err
+        return str
+}
+
+func (any *objectAny) Get(path ...interface{}) Any {
+        if len(path) == 0 {
+                return any
+        }
+        switch firstPath := path[0].(type) {
+        case string:
+                field := any.val.FieldByName(firstPath)
+                if !field.IsValid() {
+                        return newInvalidAny(path)
+                }
+                return Wrap(field.Interface())
+        case int32:
+                if '*' == firstPath {
+                        mappedAll := map[string]Any{}
+                        for i := 0; i < any.val.NumField(); i++ {
+                                field := any.val.Field(i)
+                                if field.CanInterface() {
+                                        mapped := Wrap(field.Interface()).Get(path[1:]...)
+                                        if mapped.ValueType() != InvalidValue {
+                                                mappedAll[any.val.Type().Field(i).Name] = mapped
+                                        }
+                                }
+                        }
+                        return wrapMap(mappedAll)
+                }
+                return newInvalidAny(path)
+        default:
+                return newInvalidAny(path)
+        }
+}
+
+func (any *objectAny) Keys() []string {
+        keys := make([]string, 0, any.val.NumField())
+        for i := 0; i < any.val.NumField(); i++ {
+                keys = append(keys, any.val.Type().Field(i).Name)
+        }
+        return keys
+}
+
+func (any *objectAny) Size() int {
+        return any.val.NumField()
+}
+
+func (any *objectAny) WriteTo(stream *Stream) {
+        stream.WriteVal(any.val)
+}
+
+func (any *objectAny) GetInterface() interface{} {
+        return any.val.Interface()
+}
+
+type mapAny struct {
+        baseAny
+        err error
+        val reflect.Value
+}
+
+func wrapMap(val interface{}) *mapAny {
+        return &mapAny{baseAny{}, nil, reflect.ValueOf(val)}
+}
+
+func (any *mapAny) ValueType() ValueType {
+        return ObjectValue
+}
+
+func (any *mapAny) MustBeValid() Any {
+        return any
+}
+
+func (any *mapAny) Parse() *Iterator {
+        return nil
+}
+
+func (any *mapAny) LastError() error {
+        return any.err
+}
+
+func (any *mapAny) ToBool() bool {
+        return true
+}
+
+func (any *mapAny) ToInt() int {
+        return 0
+}
+
+func (any *mapAny) ToInt32() int32 {
+        return 0
+}
+
+func (any *mapAny) ToInt64() int64 {
+        return 0
+}
+
+func (any *mapAny) ToUint() uint {
+        return 0
+}
+
+func (any *mapAny) ToUint32() uint32 {
+        return 0
+}
+
+func (any *mapAny) ToUint64() uint64 {
+        return 0
+}
+
+func (any *mapAny) ToFloat32() float32 {
+        return 0
+}
+
+func (any *mapAny) ToFloat64() float64 {
+        return 0
+}
+
+func (any *mapAny) ToString() string {
+        str, err := MarshalToString(any.val.Interface())
+        any.err = err
+        return str
+}
+
+func (any *mapAny) Get(path ...interface{}) Any {
+        if len(path) == 0 {
+                return any
+        }
+        switch firstPath := path[0].(type) {
+        case int32:
+                if '*' == firstPath {
+                        mappedAll := map[string]Any{}
+                        for _, key := range any.val.MapKeys() {
+                                keyAsStr := key.String()
+                                element := Wrap(any.val.MapIndex(key).Interface())
+                                mapped := element.Get(path[1:]...)
+                                if mapped.ValueType() != InvalidValue {
+                                        mappedAll[keyAsStr] = mapped
+                                }
+                        }
+                        return wrapMap(mappedAll)
+                }
+                return newInvalidAny(path)
+        default:
+                value := any.val.MapIndex(reflect.ValueOf(firstPath))
+                if !value.IsValid() {
+                        return newInvalidAny(path)
+                }
+                return Wrap(value.Interface())
+        }
+}
+
+func (any *mapAny) Keys() []string {
+        keys := make([]string, 0, any.val.Len())
+        for _, key := range any.val.MapKeys() {
+                keys = append(keys, key.String())
+        }
+        return keys
+}
+
+func (any *mapAny) Size() int {
+        return any.val.Len()
+}
+
+func (any *mapAny) WriteTo(stream *Stream) {
+        stream.WriteVal(any.val)
+}
+
+func (any *mapAny) GetInterface() interface{} {
+        return any.val.Interface()
+}
diff --git a/vendor/github.com/json-iterator/go/any_str.go b/vendor/github.com/json-iterator/go/any_str.go
new file mode 100644
index 0000000..1f12f66
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_str.go
@@ -0,0 +1,166 @@
+package jsoniter
+
+import (
+        "fmt"
+        "strconv"
+)
+
+type stringAny struct {
+        baseAny
+        val string
+}
+
+func (any *stringAny) Get(path ...interface{}) Any {
+        if len(path) == 0 {
+                return any
+        }
+        return &invalidAny{baseAny{}, fmt.Errorf("GetIndex %v from simple value", path)}
+}
+
+func (any *stringAny) Parse() *Iterator {
+        return nil
+}
+
+func (any *stringAny) ValueType() ValueType {
+        return StringValue
+}
+
+func (any *stringAny) MustBeValid() Any {
+        return any
+}
+
+func (any *stringAny) LastError() error {
+        return nil
+}
+
+func (any *stringAny) ToBool() bool {
+        str := any.ToString()
+        if str == "0" {
+                return false
+        }
+        for _, c := range str {
+                switch c {
+                case ' ', '\n', '\r', '\t':
+                default:
+                        return true
+                }
+        }
+        return false
+}
+
+func (any *stringAny) ToInt() int {
+        return int(any.ToInt64())
+
+}
+
+func (any *stringAny) ToInt32() int32 {
+        return int32(any.ToInt64())
+}
+
+func (any *stringAny) ToInt64() int64 {
+        if any.val == "" {
+                return 0
+        }
+
+        flag := 1
+        startPos := 0
+        if any.val[0] == '+' || any.val[0] == '-' {
+                startPos = 1
+        }
+
+        if any.val[0] == '-' {
+                flag = -1
+        }
+
+        endPos := startPos
+        for i := startPos; i < len(any.val); i++ {
+                if any.val[i] >= '0' && any.val[i] <= '9' {
+                        endPos = i + 1
+                } else {
+                        break
+                }
+        }
+        parsed, _ := strconv.ParseInt(any.val[startPos:endPos], 10, 64)
+        return int64(flag) * parsed
+}
+
+func (any *stringAny) ToUint() uint {
+        return uint(any.ToUint64())
+}
+
+func (any *stringAny) ToUint32() uint32 {
+        return uint32(any.ToUint64())
+}
+
+func (any *stringAny) ToUint64() uint64 {
+        if any.val == "" {
+                return 0
+        }
+
+        startPos := 0
+
+        if any.val[0] == '-' {
+                return 0
+        }
+        if any.val[0] == '+' {
+                startPos = 1
+        }
+
+        endPos := startPos
+        for i := startPos; i < len(any.val); i++ {
+                if any.val[i] >= '0' && any.val[i] <= '9' {
+                        endPos = i + 1
+                } else {
+                        break
+                }
+        }
+        parsed, _ := strconv.ParseUint(any.val[startPos:endPos], 10, 64)
+        return parsed
+}
+
+func (any *stringAny) ToFloat32() float32 {
+        return float32(any.ToFloat64())
+}
+
+func (any *stringAny) ToFloat64() float64 {
+        if len(any.val) == 0 {
+                return 0
+        }
+
+        // first char invalid
+        if any.val[0] != '+' && any.val[0] != '-' && (any.val[0] > '9' || any.val[0] < '0') {
+                return 0
+        }
+
+        // extract valid num expression from string
+        // eg 123true => 123, -12.12xxa => -12.12
+        endPos := 1
+        for i := 1; i < len(any.val); i++ {
+                if any.val[i] == '.' || any.val[i] == 'e' || any.val[i] == 'E' || any.val[i] == '+' || any.val[i] == '-' {
+                        endPos = i + 1
+                        continue
+                }
+
+                // end position is the first char which is not digit
+                if any.val[i] >= '0' && any.val[i] <= '9' {
+                        endPos = i + 1
+                } else {
+                        endPos = i
+                        break
+                }
+        }
+        parsed, _ := strconv.ParseFloat(any.val[:endPos], 64)
+        return parsed
+}
+
+func (any *stringAny) ToString() string {
+        return any.val
+}
+
+func (any *stringAny) WriteTo(stream *Stream) {
+        stream.WriteString(any.val)
+}
+
+func (any *stringAny) GetInterface() interface{} {
+        return any.val
+}
diff --git a/vendor/github.com/json-iterator/go/any_uint32.go b/vendor/github.com/json-iterator/go/any_uint32.go
new file mode 100644
index 0000000..656bbd3
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_uint32.go
@@ -0,0 +1,74 @@
+package jsoniter
+
+import (
+        "strconv"
+)
+
+type uint32Any struct {
+        baseAny
+        val uint32
+}
+
+func (any *uint32Any) LastError() error {
+        return nil
+}
+
+func (any *uint32Any) ValueType() ValueType {
+        return NumberValue
+}
+
+func (any *uint32Any) MustBeValid() Any {
+        return any
+}
+
+func (any *uint32Any) ToBool() bool {
+        return any.val != 0
+}
+
+func (any *uint32Any) ToInt() int {
+        return int(any.val)
+}
+
+func (any *uint32Any) ToInt32() int32 {
+        return int32(any.val)
+}
+
+func (any *uint32Any) ToInt64() int64 {
+        return int64(any.val)
+}
+
+func (any *uint32Any) ToUint() uint {
+        return uint(any.val)
+}
+
+func (any *uint32Any) ToUint32() uint32 {
+        return any.val
+}
+
+func (any *uint32Any) ToUint64() uint64 {
+        return uint64(any.val)
+}
+
+func (any *uint32Any) ToFloat32() float32 {
+        return float32(any.val)
+}
+
+func (any *uint32Any) ToFloat64() float64 {
+        return float64(any.val)
+}
+
+func (any *uint32Any) ToString() string {
+        return strconv.FormatInt(int64(any.val), 10)
+}
+
+func (any *uint32Any) WriteTo(stream *Stream) {
+        stream.WriteUint32(any.val)
+}
+
+func (any *uint32Any) Parse() *Iterator {
+        return nil
+}
+
+func (any *uint32Any) GetInterface() interface{} {
+        return any.val
+}
diff --git a/vendor/github.com/json-iterator/go/any_uint64.go b/vendor/github.com/json-iterator/go/any_uint64.go
new file mode 100644
index 0000000..7df2fce
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/any_uint64.go
@@ -0,0 +1,74 @@
+package jsoniter
+
+import (
+        "strconv"
+)
+
+type uint64Any struct {
+        baseAny
+        val uint64
+}
+
+func (any *uint64Any) LastError() error {
+        return nil
+}
+
+func (any *uint64Any) ValueType() ValueType {
+        return NumberValue
+}
+
+func (any *uint64Any) MustBeValid() Any {
+        return any
+}
+
+func (any *uint64Any) ToBool() bool {
+        return any.val != 0
+}
+
+func (any *uint64Any) ToInt() int {
+        return int(any.val)
+}
+
+func (any *uint64Any) ToInt32() int32 {
+        return int32(any.val)
+}
+
+func (any *uint64Any) ToInt64() int64 {
+        return int64(any.val)
+}
+
+func (any *uint64Any) ToUint() uint {
+        return uint(any.val)
+}
+
+func (any *uint64Any) ToUint32() uint32 {
+        return uint32(any.val)
+}
+
+func (any *uint64Any) ToUint64() uint64 {
+        return any.val
+}
+
+func (any *uint64Any) ToFloat32() float32 {
+        return float32(any.val)
+}
+
+func (any *uint64Any) ToFloat64() float64 {
+        return float64(any.val)
+}
+
+func (any *uint64Any) ToString() string {
+        return strconv.FormatUint(any.val, 10)
+}
+
+func (any *uint64Any) WriteTo(stream *Stream) {
+        stream.WriteUint64(any.val)
+}
+
+func (any *uint64Any) Parse() *Iterator {
+        return nil
+}
+
+func (any *uint64Any) GetInterface() interface{} {
+        return any.val
+}
diff --git a/vendor/github.com/json-iterator/go/build.sh b/vendor/github.com/json-iterator/go/build.sh
new file mode 100644
index 0000000..b45ef68
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/build.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+set -x
+
+if [ ! -d /tmp/build-golang/src/github.com/json-iterator ]; then
+    mkdir -p /tmp/build-golang/src/github.com/json-iterator
+    ln -s $PWD /tmp/build-golang/src/github.com/json-iterator/go
+fi
+export GOPATH=/tmp/build-golang
+go get -u github.com/golang/dep/cmd/dep
+cd /tmp/build-golang/src/github.com/json-iterator/go
+exec $GOPATH/bin/dep ensure -update
diff --git a/vendor/github.com/json-iterator/go/config.go b/vendor/github.com/json-iterator/go/config.go
new file mode 100644
index 0000000..2adcdc3
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/config.go
@@ -0,0 +1,375 @@
+package jsoniter
+
+import (
+        "encoding/json"
+        "io"
+        "reflect"
+        "sync"
+        "unsafe"
+
+        "github.com/modern-go/concurrent"
+        "github.com/modern-go/reflect2"
+)
+
+// Config customize how the API should behave.
+// The API is created from Config by Froze.
+type Config struct {
+        IndentionStep                 int
+        MarshalFloatWith6Digits       bool
+        EscapeHTML                    bool
+        SortMapKeys                   bool
+        UseNumber                     bool
+        DisallowUnknownFields         bool
+        TagKey                        string
+        OnlyTaggedField               bool
+        ValidateJsonRawMessage        bool
+        ObjectFieldMustBeSimpleString bool
+        CaseSensitive                 bool
+}
+
+// API the public interface of this package.
+// Primary Marshal and Unmarshal.
+type API interface {
+        IteratorPool
+        StreamPool
+        MarshalToString(v interface{}) (string, error)
+        Marshal(v interface{}) ([]byte, error)
+        MarshalIndent(v interface{}, prefix, indent string) ([]byte, error)
+        UnmarshalFromString(str string, v interface{}) error
+        Unmarshal(data []byte, v interface{}) error
+        Get(data []byte, path ...interface{}) Any
+        NewEncoder(writer io.Writer) *Encoder
+        NewDecoder(reader io.Reader) *Decoder
+        Valid(data []byte) bool
+        RegisterExtension(extension Extension)
+        DecoderOf(typ reflect2.Type) ValDecoder
+        EncoderOf(typ reflect2.Type) ValEncoder
+}
+
+// ConfigDefault the default API
+var ConfigDefault = Config{
+        EscapeHTML: true,
+}.Froze()
+
+// ConfigCompatibleWithStandardLibrary tries to be 100% compatible with standard library behavior
+var ConfigCompatibleWithStandardLibrary = Config{
+        EscapeHTML:             true,
+        SortMapKeys:            true,
+        ValidateJsonRawMessage: true,
+}.Froze()
+
+// ConfigFastest marshals float with only 6 digits precision
+var ConfigFastest = Config{
+        EscapeHTML:                    false,
+        MarshalFloatWith6Digits:       true, // will lose precession
+        ObjectFieldMustBeSimpleString: true, // do not unescape object field
+}.Froze()
+
+type frozenConfig struct {
+        configBeforeFrozen            Config
+        sortMapKeys                   bool
+        indentionStep                 int
+        objectFieldMustBeSimpleString bool
+        onlyTaggedField               bool
+        disallowUnknownFields         bool
+        decoderCache                  *concurrent.Map
+        encoderCache                  *concurrent.Map
+        encoderExtension              Extension
+        decoderExtension              Extension
+        extraExtensions               []Extension
+        streamPool                    *sync.Pool
+        iteratorPool                  *sync.Pool
+        caseSensitive                 bool
+}
+
+func (cfg *frozenConfig) initCache() {
+        cfg.decoderCache = concurrent.NewMap()
+        cfg.encoderCache = concurrent.NewMap()
+}
+
+func (cfg *frozenConfig) addDecoderToCache(cacheKey uintptr, decoder ValDecoder) {
+        cfg.decoderCache.Store(cacheKey, decoder)
+}
+
+func (cfg *frozenConfig) addEncoderToCache(cacheKey uintptr, encoder ValEncoder) {
+        cfg.encoderCache.Store(cacheKey, encoder)
+}
+
+func (cfg *frozenConfig) getDecoderFromCache(cacheKey uintptr) ValDecoder {
+        decoder, found := cfg.decoderCache.Load(cacheKey)
+        if found {
+                return decoder.(ValDecoder)
+        }
+        return nil
+}
+
+func (cfg *frozenConfig) getEncoderFromCache(cacheKey uintptr) ValEncoder {
+        encoder, found := cfg.encoderCache.Load(cacheKey)
+        if found {
+                return encoder.(ValEncoder)
+        }
+        return nil
+}
+
+var cfgCache = concurrent.NewMap()
+
+func getFrozenConfigFromCache(cfg Config) *frozenConfig {
+        obj, found := cfgCache.Load(cfg)
+        if found {
+                return obj.(*frozenConfig)
+        }
+        return nil
+}
+
+func addFrozenConfigToCache(cfg Config, frozenConfig *frozenConfig) {
+        cfgCache.Store(cfg, frozenConfig)
+}
+
+// Froze forge API from config
+func (cfg Config) Froze() API {
+        api := &frozenConfig{
+                sortMapKeys:                   cfg.SortMapKeys,
+                indentionStep:                 cfg.IndentionStep,
+                objectFieldMustBeSimpleString: cfg.ObjectFieldMustBeSimpleString,
+                onlyTaggedField:               cfg.OnlyTaggedField,
+                disallowUnknownFields:         cfg.DisallowUnknownFields,
+                caseSensitive:                 cfg.CaseSensitive,
+        }
+        api.streamPool = &sync.Pool{
+                New: func() interface{} {
+                        return NewStream(api, nil, 512)
+                },
+        }
+        api.iteratorPool = &sync.Pool{
+                New: func() interface{} {
+                        return NewIterator(api)
+                },
+        }
+        api.initCache()
+        encoderExtension := EncoderExtension{}
+        decoderExtension := DecoderExtension{}
+        if cfg.MarshalFloatWith6Digits {
+                api.marshalFloatWith6Digits(encoderExtension)
+        }
+        if cfg.EscapeHTML {
+                api.escapeHTML(encoderExtension)
+        }
+        if cfg.UseNumber {
+                api.useNumber(decoderExtension)
+        }
+        if cfg.ValidateJsonRawMessage {
+                api.validateJsonRawMessage(encoderExtension)
+        }
+        api.encoderExtension = encoderExtension
+        api.decoderExtension = decoderExtension
+        api.configBeforeFrozen = cfg
+        return api
+}
+
+func (cfg Config) frozeWithCacheReuse(extraExtensions []Extension) *frozenConfig {
+        api := getFrozenConfigFromCache(cfg)
+        if api != nil {
+                return api
+        }
+        api = cfg.Froze().(*frozenConfig)
+        for _, extension := range extraExtensions {
+                api.RegisterExtension(extension)
+        }
+        addFrozenConfigToCache(cfg, api)
+        return api
+}
+
+func (cfg *frozenConfig) validateJsonRawMessage(extension EncoderExtension) {
+        encoder := &funcEncoder{func(ptr unsafe.Pointer, stream *Stream) {
+                rawMessage := *(*json.RawMessage)(ptr)
+                iter := cfg.BorrowIterator([]byte(rawMessage))
+                defer cfg.ReturnIterator(iter)
+                iter.Read()
+                if iter.Error != nil && iter.Error != io.EOF {
+                        stream.WriteRaw("null")
+                } else {
+                        stream.WriteRaw(string(rawMessage))
+                }
+        }, func(ptr unsafe.Pointer) bool {
+                return len(*((*json.RawMessage)(ptr))) == 0
+        }}
+        extension[reflect2.TypeOfPtr((*json.RawMessage)(nil)).Elem()] = encoder
+        extension[reflect2.TypeOfPtr((*RawMessage)(nil)).Elem()] = encoder
+}
+
+func (cfg *frozenConfig) useNumber(extension DecoderExtension) {
+        extension[reflect2.TypeOfPtr((*interface{})(nil)).Elem()] = &funcDecoder{func(ptr unsafe.Pointer, iter *Iterator) {
+                exitingValue := *((*interface{})(ptr))
+                if exitingValue != nil && reflect.TypeOf(exitingValue).Kind() == reflect.Ptr {
+                        iter.ReadVal(exitingValue)
+                        return
+                }
+                if iter.WhatIsNext() == NumberValue {
+                        *((*interface{})(ptr)) = json.Number(iter.readNumberAsString())
+                } else {
+                        *((*interface{})(ptr)) = iter.Read()
+                }
+        }}
+}
+func (cfg *frozenConfig) getTagKey() string {
+        tagKey := cfg.configBeforeFrozen.TagKey
+        if tagKey == "" {
+                return "json"
+        }
+        return tagKey
+}
+
+func (cfg *frozenConfig) RegisterExtension(extension Extension) {
+        cfg.extraExtensions = append(cfg.extraExtensions, extension)
+        copied := cfg.configBeforeFrozen
+        cfg.configBeforeFrozen = copied
+}
+
+type lossyFloat32Encoder struct {
+}
+
+func (encoder *lossyFloat32Encoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteFloat32Lossy(*((*float32)(ptr)))
+}
+
+func (encoder *lossyFloat32Encoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*float32)(ptr)) == 0
+}
+
+type lossyFloat64Encoder struct {
+}
+
+func (encoder *lossyFloat64Encoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteFloat64Lossy(*((*float64)(ptr)))
+}
+
+func (encoder *lossyFloat64Encoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*float64)(ptr)) == 0
+}
+
+// EnableLossyFloatMarshalling keeps 10**(-6) precision
+// for float variables for better performance.
+func (cfg *frozenConfig) marshalFloatWith6Digits(extension EncoderExtension) {
+        // for better performance
+        extension[reflect2.TypeOfPtr((*float32)(nil)).Elem()] = &lossyFloat32Encoder{}
+        extension[reflect2.TypeOfPtr((*float64)(nil)).Elem()] = &lossyFloat64Encoder{}
+}
+
+type htmlEscapedStringEncoder struct {
+}
+
+func (encoder *htmlEscapedStringEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        str := *((*string)(ptr))
+        stream.WriteStringWithHTMLEscaped(str)
+}
+
+func (encoder *htmlEscapedStringEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*string)(ptr)) == ""
+}
+
+func (cfg *frozenConfig) escapeHTML(encoderExtension EncoderExtension) {
+        encoderExtension[reflect2.TypeOfPtr((*string)(nil)).Elem()] = &htmlEscapedStringEncoder{}
+}
+
+func (cfg *frozenConfig) cleanDecoders() {
+        typeDecoders = map[string]ValDecoder{}
+        fieldDecoders = map[string]ValDecoder{}
+        *cfg = *(cfg.configBeforeFrozen.Froze().(*frozenConfig))
+}
+
+func (cfg *frozenConfig) cleanEncoders() {
+        typeEncoders = map[string]ValEncoder{}
+        fieldEncoders = map[string]ValEncoder{}
+        *cfg = *(cfg.configBeforeFrozen.Froze().(*frozenConfig))
+}
+
+func (cfg *frozenConfig) MarshalToString(v interface{}) (string, error) {
+        stream := cfg.BorrowStream(nil)
+        defer cfg.ReturnStream(stream)
+        stream.WriteVal(v)
+        if stream.Error != nil {
+                return "", stream.Error
+        }
+        return string(stream.Buffer()), nil
+}
+
+func (cfg *frozenConfig) Marshal(v interface{}) ([]byte, error) {
+        stream := cfg.BorrowStream(nil)
+        defer cfg.ReturnStream(stream)
+        stream.WriteVal(v)
+        if stream.Error != nil {
+                return nil, stream.Error
+        }
+        result := stream.Buffer()
+        copied := make([]byte, len(result))
+        copy(copied, result)
+        return copied, nil
+}
+
+func (cfg *frozenConfig) MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
+        if prefix != "" {
+                panic("prefix is not supported")
+        }
+        for _, r := range indent {
+                if r != ' ' {
+                        panic("indent can only be space")
+                }
+        }
+        newCfg := cfg.configBeforeFrozen
+        newCfg.IndentionStep = len(indent)
+        return newCfg.frozeWithCacheReuse(cfg.extraExtensions).Marshal(v)
+}
+
+func (cfg *frozenConfig) UnmarshalFromString(str string, v interface{}) error {
+        data := []byte(str)
+        iter := cfg.BorrowIterator(data)
+        defer cfg.ReturnIterator(iter)
+        iter.ReadVal(v)
+        c := iter.nextToken()
+        if c == 0 {
+                if iter.Error == io.EOF {
+                        return nil
+                }
+                return iter.Error
+        }
+        iter.ReportError("Unmarshal", "there are bytes left after unmarshal")
+        return iter.Error
+}
+
+func (cfg *frozenConfig) Get(data []byte, path ...interface{}) Any {
+        iter := cfg.BorrowIterator(data)
+        defer cfg.ReturnIterator(iter)
+        return locatePath(iter, path)
+}
+
+func (cfg *frozenConfig) Unmarshal(data []byte, v interface{}) error {
+        iter := cfg.BorrowIterator(data)
+        defer cfg.ReturnIterator(iter)
+        iter.ReadVal(v)
+        c := iter.nextToken()
+        if c == 0 {
+                if iter.Error == io.EOF {
+                        return nil
+                }
+                return iter.Error
+        }
+        iter.ReportError("Unmarshal", "there are bytes left after unmarshal")
+        return iter.Error
+}
+
+func (cfg *frozenConfig) NewEncoder(writer io.Writer) *Encoder {
+        stream := NewStream(cfg, writer, 512)
+        return &Encoder{stream}
+}
+
+func (cfg *frozenConfig) NewDecoder(reader io.Reader) *Decoder {
+        iter := Parse(cfg, reader, 512)
+        return &Decoder{iter}
+}
+
+func (cfg *frozenConfig) Valid(data []byte) bool {
+        iter := cfg.BorrowIterator(data)
+        defer cfg.ReturnIterator(iter)
+        iter.Skip()
+        return iter.Error == nil
+}
diff --git a/vendor/github.com/json-iterator/go/fuzzy_mode_convert_table.md b/vendor/github.com/json-iterator/go/fuzzy_mode_convert_table.md
new file mode 100644
index 0000000..3095662
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/fuzzy_mode_convert_table.md
@@ -0,0 +1,7 @@
+| json type \ dest type | bool | int | uint | float |string|
+| --- | --- | --- | --- |--|--|
+| number | positive => true <br/> negative => true <br/> zero => false| 23.2 => 23 <br/> -32.1 => -32| 12.1 => 12 <br/> -12.1 => 0|as normal|same as origin|
+| string | empty string => false <br/> string "0" => false <br/> other strings => true | "123.32" => 123 <br/> "-123.4" => -123 <br/> "123.23xxxw" => 123 <br/>  "abcde12" => 0 <br/> "-32.1" => -32| 13.2 => 13 <br/> -1.1 => 0 |12.1 => 12.1 <br/> -12.3 => -12.3<br/> 12.4xxa => 12.4 <br/> +1.1e2 =>110 |same as origin|
+| bool | true => true <br/> false => false| true => 1 <br/> false => 0 | true => 1 <br/> false => 0 |true => 1 <br/>false => 0|true => "true" <br/> false => "false"|
+| object | true | 0 | 0 |0|originnal json|
+| array | empty array => false <br/> nonempty array => true| [] => 0 <br/> [1,2] => 1 | [] => 0 <br/> [1,2] => 1 |[] => 0<br/>[1,2] => 1|original json|
\ No newline at end of file
diff --git a/vendor/github.com/json-iterator/go/iter.go b/vendor/github.com/json-iterator/go/iter.go
new file mode 100644
index 0000000..29b31cf
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/iter.go
@@ -0,0 +1,349 @@
+package jsoniter
+
+import (
+        "encoding/json"
+        "fmt"
+        "io"
+)
+
+// ValueType the type for JSON element
+type ValueType int
+
+const (
+        // InvalidValue invalid JSON element
+        InvalidValue ValueType = iota
+        // StringValue JSON element "string"
+        StringValue
+        // NumberValue JSON element 100 or 0.10
+        NumberValue
+        // NilValue JSON element null
+        NilValue
+        // BoolValue JSON element true or false
+        BoolValue
+        // ArrayValue JSON element []
+        ArrayValue
+        // ObjectValue JSON element {}
+        ObjectValue
+)
+
+var hexDigits []byte
+var valueTypes []ValueType
+
+func init() {
+        hexDigits = make([]byte, 256)
+        for i := 0; i < len(hexDigits); i++ {
+                hexDigits[i] = 255
+        }
+        for i := '0'; i <= '9'; i++ {
+                hexDigits[i] = byte(i - '0')
+        }
+        for i := 'a'; i <= 'f'; i++ {
+                hexDigits[i] = byte((i - 'a') + 10)
+        }
+        for i := 'A'; i <= 'F'; i++ {
+                hexDigits[i] = byte((i - 'A') + 10)
+        }
+        valueTypes = make([]ValueType, 256)
+        for i := 0; i < len(valueTypes); i++ {
+                valueTypes[i] = InvalidValue
+        }
+        valueTypes['"'] = StringValue
+        valueTypes['-'] = NumberValue
+        valueTypes['0'] = NumberValue
+        valueTypes['1'] = NumberValue
+        valueTypes['2'] = NumberValue
+        valueTypes['3'] = NumberValue
+        valueTypes['4'] = NumberValue
+        valueTypes['5'] = NumberValue
+        valueTypes['6'] = NumberValue
+        valueTypes['7'] = NumberValue
+        valueTypes['8'] = NumberValue
+        valueTypes['9'] = NumberValue
+        valueTypes['t'] = BoolValue
+        valueTypes['f'] = BoolValue
+        valueTypes['n'] = NilValue
+        valueTypes['['] = ArrayValue
+        valueTypes['{'] = ObjectValue
+}
+
+// Iterator is a io.Reader like object, with JSON specific read functions.
+// Error is not returned as return value, but stored as Error member on this iterator instance.
+type Iterator struct {
+        cfg              *frozenConfig
+        reader           io.Reader
+        buf              []byte
+        head             int
+        tail             int
+        depth            int
+        captureStartedAt int
+        captured         []byte
+        Error            error
+        Attachment       interface{} // open for customized decoder
+}
+
+// NewIterator creates an empty Iterator instance
+func NewIterator(cfg API) *Iterator {
+        return &Iterator{
+                cfg:    cfg.(*frozenConfig),
+                reader: nil,
+                buf:    nil,
+                head:   0,
+                tail:   0,
+                depth:  0,
+        }
+}
+
+// Parse creates an Iterator instance from io.Reader
+func Parse(cfg API, reader io.Reader, bufSize int) *Iterator {
+        return &Iterator{
+                cfg:    cfg.(*frozenConfig),
+                reader: reader,
+                buf:    make([]byte, bufSize),
+                head:   0,
+                tail:   0,
+                depth:  0,
+        }
+}
+
+// ParseBytes creates an Iterator instance from byte array
+func ParseBytes(cfg API, input []byte) *Iterator {
+        return &Iterator{
+                cfg:    cfg.(*frozenConfig),
+                reader: nil,
+                buf:    input,
+                head:   0,
+                tail:   len(input),
+                depth:  0,
+        }
+}
+
+// ParseString creates an Iterator instance from string
+func ParseString(cfg API, input string) *Iterator {
+        return ParseBytes(cfg, []byte(input))
+}
+
+// Pool returns a pool can provide more iterator with same configuration
+func (iter *Iterator) Pool() IteratorPool {
+        return iter.cfg
+}
+
+// Reset reuse iterator instance by specifying another reader
+func (iter *Iterator) Reset(reader io.Reader) *Iterator {
+        iter.reader = reader
+        iter.head = 0
+        iter.tail = 0
+        iter.depth = 0
+        return iter
+}
+
+// ResetBytes reuse iterator instance by specifying another byte array as input
+func (iter *Iterator) ResetBytes(input []byte) *Iterator {
+        iter.reader = nil
+        iter.buf = input
+        iter.head = 0
+        iter.tail = len(input)
+        iter.depth = 0
+        return iter
+}
+
+// WhatIsNext gets ValueType of relatively next json element
+func (iter *Iterator) WhatIsNext() ValueType {
+        valueType := valueTypes[iter.nextToken()]
+        iter.unreadByte()
+        return valueType
+}
+
+func (iter *Iterator) skipWhitespacesWithoutLoadMore() bool {
+        for i := iter.head; i < iter.tail; i++ {
+                c := iter.buf[i]
+                switch c {
+                case ' ', '\n', '\t', '\r':
+                        continue
+                }
+                iter.head = i
+                return false
+        }
+        return true
+}
+
+func (iter *Iterator) isObjectEnd() bool {
+        c := iter.nextToken()
+        if c == ',' {
+                return false
+        }
+        if c == '}' {
+                return true
+        }
+        iter.ReportError("isObjectEnd", "object ended prematurely, unexpected char "+string([]byte{c}))
+        return true
+}
+
+func (iter *Iterator) nextToken() byte {
+        // a variation of skip whitespaces, returning the next non-whitespace token
+        for {
+                for i := iter.head; i < iter.tail; i++ {
+                        c := iter.buf[i]
+                        switch c {
+                        case ' ', '\n', '\t', '\r':
+                                continue
+                        }
+                        iter.head = i + 1
+                        return c
+                }
+                if !iter.loadMore() {
+                        return 0
+                }
+        }
+}
+
+// ReportError record a error in iterator instance with current position.
+func (iter *Iterator) ReportError(operation string, msg string) {
+        if iter.Error != nil {
+                if iter.Error != io.EOF {
+                        return
+                }
+        }
+        peekStart := iter.head - 10
+        if peekStart < 0 {
+                peekStart = 0
+        }
+        peekEnd := iter.head + 10
+        if peekEnd > iter.tail {
+                peekEnd = iter.tail
+        }
+        parsing := string(iter.buf[peekStart:peekEnd])
+        contextStart := iter.head - 50
+        if contextStart < 0 {
+                contextStart = 0
+        }
+        contextEnd := iter.head + 50
+        if contextEnd > iter.tail {
+                contextEnd = iter.tail
+        }
+        context := string(iter.buf[contextStart:contextEnd])
+        iter.Error = fmt.Errorf("%s: %s, error found in #%v byte of ...|%s|..., bigger context ...|%s|...",
+                operation, msg, iter.head-peekStart, parsing, context)
+}
+
+// CurrentBuffer gets current buffer as string for debugging purpose
+func (iter *Iterator) CurrentBuffer() string {
+        peekStart := iter.head - 10
+        if peekStart < 0 {
+                peekStart = 0
+        }
+        return fmt.Sprintf("parsing #%v byte, around ...|%s|..., whole buffer ...|%s|...", iter.head,
+                string(iter.buf[peekStart:iter.head]), string(iter.buf[0:iter.tail]))
+}
+
+func (iter *Iterator) readByte() (ret byte) {
+        if iter.head == iter.tail {
+                if iter.loadMore() {
+                        ret = iter.buf[iter.head]
+                        iter.head++
+                        return ret
+                }
+                return 0
+        }
+        ret = iter.buf[iter.head]
+        iter.head++
+        return ret
+}
+
+func (iter *Iterator) loadMore() bool {
+        if iter.reader == nil {
+                if iter.Error == nil {
+                        iter.head = iter.tail
+                        iter.Error = io.EOF
+                }
+                return false
+        }
+        if iter.captured != nil {
+                iter.captured = append(iter.captured,
+                        iter.buf[iter.captureStartedAt:iter.tail]...)
+                iter.captureStartedAt = 0
+        }
+        for {
+                n, err := iter.reader.Read(iter.buf)
+                if n == 0 {
+                        if err != nil {
+                                if iter.Error == nil {
+                                        iter.Error = err
+                                }
+                                return false
+                        }
+                } else {
+                        iter.head = 0
+                        iter.tail = n
+                        return true
+                }
+        }
+}
+
+func (iter *Iterator) unreadByte() {
+        if iter.Error != nil {
+                return
+        }
+        iter.head--
+        return
+}
+
+// Read read the next JSON element as generic interface{}.
+func (iter *Iterator) Read() interface{} {
+        valueType := iter.WhatIsNext()
+        switch valueType {
+        case StringValue:
+                return iter.ReadString()
+        case NumberValue:
+                if iter.cfg.configBeforeFrozen.UseNumber {
+                        return json.Number(iter.readNumberAsString())
+                }
+                return iter.ReadFloat64()
+        case NilValue:
+                iter.skipFourBytes('n', 'u', 'l', 'l')
+                return nil
+        case BoolValue:
+                return iter.ReadBool()
+        case ArrayValue:
+                arr := []interface{}{}
+                iter.ReadArrayCB(func(iter *Iterator) bool {
+                        var elem interface{}
+                        iter.ReadVal(&elem)
+                        arr = append(arr, elem)
+                        return true
+                })
+                return arr
+        case ObjectValue:
+                obj := map[string]interface{}{}
+                iter.ReadMapCB(func(Iter *Iterator, field string) bool {
+                        var elem interface{}
+                        iter.ReadVal(&elem)
+                        obj[field] = elem
+                        return true
+                })
+                return obj
+        default:
+                iter.ReportError("Read", fmt.Sprintf("unexpected value type: %v", valueType))
+                return nil
+        }
+}
+
+// limit maximum depth of nesting, as allowed by https://tools.ietf.org/html/rfc7159#section-9
+const maxDepth = 10000
+
+func (iter *Iterator) incrementDepth() (success bool) {
+        iter.depth++
+        if iter.depth <= maxDepth {
+                return true
+        }
+        iter.ReportError("incrementDepth", "exceeded max depth")
+        return false
+}
+
+func (iter *Iterator) decrementDepth() (success bool) {
+        iter.depth--
+        if iter.depth >= 0 {
+                return true
+        }
+        iter.ReportError("decrementDepth", "unexpected negative nesting")
+        return false
+}
diff --git a/vendor/github.com/json-iterator/go/iter_array.go b/vendor/github.com/json-iterator/go/iter_array.go
new file mode 100644
index 0000000..204fe0e
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/iter_array.go
@@ -0,0 +1,64 @@
+package jsoniter
+
+// ReadArray read array element, tells if the array has more element to read.
+func (iter *Iterator) ReadArray() (ret bool) {
+        c := iter.nextToken()
+        switch c {
+        case 'n':
+                iter.skipThreeBytes('u', 'l', 'l')
+                return false // null
+        case '[':
+                c = iter.nextToken()
+                if c != ']' {
+                        iter.unreadByte()
+                        return true
+                }
+                return false
+        case ']':
+                return false
+        case ',':
+                return true
+        default:
+                iter.ReportError("ReadArray", "expect [ or , or ] or n, but found "+string([]byte{c}))
+                return
+        }
+}
+
+// ReadArrayCB read array with callback
+func (iter *Iterator) ReadArrayCB(callback func(*Iterator) bool) (ret bool) {
+        c := iter.nextToken()
+        if c == '[' {
+                if !iter.incrementDepth() {
+                        return false
+                }
+                c = iter.nextToken()
+                if c != ']' {
+                        iter.unreadByte()
+                        if !callback(iter) {
+                                iter.decrementDepth()
+                                return false
+                        }
+                        c = iter.nextToken()
+                        for c == ',' {
+                                if !callback(iter) {
+                                        iter.decrementDepth()
+                                        return false
+                                }
+                                c = iter.nextToken()
+                        }
+                        if c != ']' {
+                                iter.ReportError("ReadArrayCB", "expect ] in the end, but found "+string([]byte{c}))
+                                iter.decrementDepth()
+                                return false
+                        }
+                        return iter.decrementDepth()
+                }
+                return iter.decrementDepth()
+        }
+        if c == 'n' {
+                iter.skipThreeBytes('u', 'l', 'l')
+                return true // null
+        }
+        iter.ReportError("ReadArrayCB", "expect [ or n, but found "+string([]byte{c}))
+        return false
+}
diff --git a/vendor/github.com/json-iterator/go/iter_float.go b/vendor/github.com/json-iterator/go/iter_float.go
new file mode 100644
index 0000000..8a3d8b6
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/iter_float.go
@@ -0,0 +1,342 @@
+package jsoniter
+
+import (
+        "encoding/json"
+        "io"
+        "math/big"
+        "strconv"
+        "strings"
+        "unsafe"
+)
+
+var floatDigits []int8
+
+const invalidCharForNumber = int8(-1)
+const endOfNumber = int8(-2)
+const dotInNumber = int8(-3)
+
+func init() {
+        floatDigits = make([]int8, 256)
+        for i := 0; i < len(floatDigits); i++ {
+                floatDigits[i] = invalidCharForNumber
+        }
+        for i := int8('0'); i <= int8('9'); i++ {
+                floatDigits[i] = i - int8('0')
+        }
+        floatDigits[','] = endOfNumber
+        floatDigits[']'] = endOfNumber
+        floatDigits['}'] = endOfNumber
+        floatDigits[' '] = endOfNumber
+        floatDigits['\t'] = endOfNumber
+        floatDigits['\n'] = endOfNumber
+        floatDigits['.'] = dotInNumber
+}
+
+// ReadBigFloat read big.Float
+func (iter *Iterator) ReadBigFloat() (ret *big.Float) {
+        str := iter.readNumberAsString()
+        if iter.Error != nil && iter.Error != io.EOF {
+                return nil
+        }
+        prec := 64
+        if len(str) > prec {
+                prec = len(str)
+        }
+        val, _, err := big.ParseFloat(str, 10, uint(prec), big.ToZero)
+        if err != nil {
+                iter.Error = err
+                return nil
+        }
+        return val
+}
+
+// ReadBigInt read big.Int
+func (iter *Iterator) ReadBigInt() (ret *big.Int) {
+        str := iter.readNumberAsString()
+        if iter.Error != nil && iter.Error != io.EOF {
+                return nil
+        }
+        ret = big.NewInt(0)
+        var success bool
+        ret, success = ret.SetString(str, 10)
+        if !success {
+                iter.ReportError("ReadBigInt", "invalid big int")
+                return nil
+        }
+        return ret
+}
+
+//ReadFloat32 read float32
+func (iter *Iterator) ReadFloat32() (ret float32) {
+        c := iter.nextToken()
+        if c == '-' {
+                return -iter.readPositiveFloat32()
+        }
+        iter.unreadByte()
+        return iter.readPositiveFloat32()
+}
+
+func (iter *Iterator) readPositiveFloat32() (ret float32) {
+        i := iter.head
+        // first char
+        if i == iter.tail {
+                return iter.readFloat32SlowPath()
+        }
+        c := iter.buf[i]
+        i++
+        ind := floatDigits[c]
+        switch ind {
+        case invalidCharForNumber:
+                return iter.readFloat32SlowPath()
+        case endOfNumber:
+                iter.ReportError("readFloat32", "empty number")
+                return
+        case dotInNumber:
+                iter.ReportError("readFloat32", "leading dot is invalid")
+                return
+        case 0:
+                if i == iter.tail {
+                        return iter.readFloat32SlowPath()
+                }
+                c = iter.buf[i]
+                switch c {
+                case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+                        iter.ReportError("readFloat32", "leading zero is invalid")
+                        return
+                }
+        }
+        value := uint64(ind)
+        // chars before dot
+non_decimal_loop:
+        for ; i < iter.tail; i++ {
+                c = iter.buf[i]
+                ind := floatDigits[c]
+                switch ind {
+                case invalidCharForNumber:
+                        return iter.readFloat32SlowPath()
+                case endOfNumber:
+                        iter.head = i
+                        return float32(value)
+                case dotInNumber:
+                        break non_decimal_loop
+                }
+                if value > uint64SafeToMultiple10 {
+                        return iter.readFloat32SlowPath()
+                }
+                value = (value << 3) + (value << 1) + uint64(ind) // value = value * 10 + ind;
+        }
+        // chars after dot
+        if c == '.' {
+                i++
+                decimalPlaces := 0
+                if i == iter.tail {
+                        return iter.readFloat32SlowPath()
+                }
+                for ; i < iter.tail; i++ {
+                        c = iter.buf[i]
+                        ind := floatDigits[c]
+                        switch ind {
+                        case endOfNumber:
+                                if decimalPlaces > 0 && decimalPlaces < len(pow10) {
+                                        iter.head = i
+                                        return float32(float64(value) / float64(pow10[decimalPlaces]))
+                                }
+                                // too many decimal places
+                                return iter.readFloat32SlowPath()
+                        case invalidCharForNumber, dotInNumber:
+                                return iter.readFloat32SlowPath()
+                        }
+                        decimalPlaces++
+                        if value > uint64SafeToMultiple10 {
+                                return iter.readFloat32SlowPath()
+                        }
+                        value = (value << 3) + (value << 1) + uint64(ind)
+                }
+        }
+        return iter.readFloat32SlowPath()
+}
+
+func (iter *Iterator) readNumberAsString() (ret string) {
+        strBuf := [16]byte{}
+        str := strBuf[0:0]
+load_loop:
+        for {
+                for i := iter.head; i < iter.tail; i++ {
+                        c := iter.buf[i]
+                        switch c {
+                        case '+', '-', '.', 'e', 'E', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+                                str = append(str, c)
+                                continue
+                        default:
+                                iter.head = i
+                                break load_loop
+                        }
+                }
+                if !iter.loadMore() {
+                        break
+                }
+        }
+        if iter.Error != nil && iter.Error != io.EOF {
+                return
+        }
+        if len(str) == 0 {
+                iter.ReportError("readNumberAsString", "invalid number")
+        }
+        return *(*string)(unsafe.Pointer(&str))
+}
+
+func (iter *Iterator) readFloat32SlowPath() (ret float32) {
+        str := iter.readNumberAsString()
+        if iter.Error != nil && iter.Error != io.EOF {
+                return
+        }
+        errMsg := validateFloat(str)
+        if errMsg != "" {
+                iter.ReportError("readFloat32SlowPath", errMsg)
+                return
+        }
+        val, err := strconv.ParseFloat(str, 32)
+        if err != nil {
+                iter.Error = err
+                return
+        }
+        return float32(val)
+}
+
+// ReadFloat64 read float64
+func (iter *Iterator) ReadFloat64() (ret float64) {
+        c := iter.nextToken()
+        if c == '-' {
+                return -iter.readPositiveFloat64()
+        }
+        iter.unreadByte()
+        return iter.readPositiveFloat64()
+}
+
+func (iter *Iterator) readPositiveFloat64() (ret float64) {
+        i := iter.head
+        // first char
+        if i == iter.tail {
+                return iter.readFloat64SlowPath()
+        }
+        c := iter.buf[i]
+        i++
+        ind := floatDigits[c]
+        switch ind {
+        case invalidCharForNumber:
+                return iter.readFloat64SlowPath()
+        case endOfNumber:
+                iter.ReportError("readFloat64", "empty number")
+                return
+        case dotInNumber:
+                iter.ReportError("readFloat64", "leading dot is invalid")
+                return
+        case 0:
+                if i == iter.tail {
+                        return iter.readFloat64SlowPath()
+                }
+                c = iter.buf[i]
+                switch c {
+                case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+                        iter.ReportError("readFloat64", "leading zero is invalid")
+                        return
+                }
+        }
+        value := uint64(ind)
+        // chars before dot
+non_decimal_loop:
+        for ; i < iter.tail; i++ {
+                c = iter.buf[i]
+                ind := floatDigits[c]
+                switch ind {
+                case invalidCharForNumber:
+                        return iter.readFloat64SlowPath()
+                case endOfNumber:
+                        iter.head = i
+                        return float64(value)
+                case dotInNumber:
+                        break non_decimal_loop
+                }
+                if value > uint64SafeToMultiple10 {
+                        return iter.readFloat64SlowPath()
+                }
+                value = (value << 3) + (value << 1) + uint64(ind) // value = value * 10 + ind;
+        }
+        // chars after dot
+        if c == '.' {
+                i++
+                decimalPlaces := 0
+                if i == iter.tail {
+                        return iter.readFloat64SlowPath()
+                }
+                for ; i < iter.tail; i++ {
+                        c = iter.buf[i]
+                        ind := floatDigits[c]
+                        switch ind {
+                        case endOfNumber:
+                                if decimalPlaces > 0 && decimalPlaces < len(pow10) {
+                                        iter.head = i
+                                        return float64(value) / float64(pow10[decimalPlaces])
+                                }
+                                // too many decimal places
+                                return iter.readFloat64SlowPath()
+                        case invalidCharForNumber, dotInNumber:
+                                return iter.readFloat64SlowPath()
+                        }
+                        decimalPlaces++
+                        if value > uint64SafeToMultiple10 {
+                                return iter.readFloat64SlowPath()
+                        }
+                        value = (value << 3) + (value << 1) + uint64(ind)
+                        if value > maxFloat64 {
+                                return iter.readFloat64SlowPath()
+                        }
+                }
+        }
+        return iter.readFloat64SlowPath()
+}
+
+func (iter *Iterator) readFloat64SlowPath() (ret float64) {
+        str := iter.readNumberAsString()
+        if iter.Error != nil && iter.Error != io.EOF {
+                return
+        }
+        errMsg := validateFloat(str)
+        if errMsg != "" {
+                iter.ReportError("readFloat64SlowPath", errMsg)
+                return
+        }
+        val, err := strconv.ParseFloat(str, 64)
+        if err != nil {
+                iter.Error = err
+                return
+        }
+        return val
+}
+
+func validateFloat(str string) string {
+        // strconv.ParseFloat is not validating `1.` or `1.e1`
+        if len(str) == 0 {
+                return "empty number"
+        }
+        if str[0] == '-' {
+                return "-- is not valid"
+        }
+        dotPos := strings.IndexByte(str, '.')
+        if dotPos != -1 {
+                if dotPos == len(str)-1 {
+                        return "dot can not be last character"
+                }
+                switch str[dotPos+1] {
+                case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+                default:
+                        return "missing digit after dot"
+                }
+        }
+        return ""
+}
+
+// ReadNumber read json.Number
+func (iter *Iterator) ReadNumber() (ret json.Number) {
+        return json.Number(iter.readNumberAsString())
+}
diff --git a/vendor/github.com/json-iterator/go/iter_int.go b/vendor/github.com/json-iterator/go/iter_int.go
new file mode 100644
index 0000000..d786a89
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/iter_int.go
@@ -0,0 +1,346 @@
+package jsoniter
+
+import (
+        "math"
+        "strconv"
+)
+
+var intDigits []int8
+
+const uint32SafeToMultiply10 = uint32(0xffffffff)/10 - 1
+const uint64SafeToMultiple10 = uint64(0xffffffffffffffff)/10 - 1
+const maxFloat64 = 1<<53 - 1
+
+func init() {
+        intDigits = make([]int8, 256)
+        for i := 0; i < len(intDigits); i++ {
+                intDigits[i] = invalidCharForNumber
+        }
+        for i := int8('0'); i <= int8('9'); i++ {
+                intDigits[i] = i - int8('0')
+        }
+}
+
+// ReadUint read uint
+func (iter *Iterator) ReadUint() uint {
+        if strconv.IntSize == 32 {
+                return uint(iter.ReadUint32())
+        }
+        return uint(iter.ReadUint64())
+}
+
+// ReadInt read int
+func (iter *Iterator) ReadInt() int {
+        if strconv.IntSize == 32 {
+                return int(iter.ReadInt32())
+        }
+        return int(iter.ReadInt64())
+}
+
+// ReadInt8 read int8
+func (iter *Iterator) ReadInt8() (ret int8) {
+        c := iter.nextToken()
+        if c == '-' {
+                val := iter.readUint32(iter.readByte())
+                if val > math.MaxInt8+1 {
+                        iter.ReportError("ReadInt8", "overflow: "+strconv.FormatInt(int64(val), 10))
+                        return
+                }
+                return -int8(val)
+        }
+        val := iter.readUint32(c)
+        if val > math.MaxInt8 {
+                iter.ReportError("ReadInt8", "overflow: "+strconv.FormatInt(int64(val), 10))
+                return
+        }
+        return int8(val)
+}
+
+// ReadUint8 read uint8
+func (iter *Iterator) ReadUint8() (ret uint8) {
+        val := iter.readUint32(iter.nextToken())
+        if val > math.MaxUint8 {
+                iter.ReportError("ReadUint8", "overflow: "+strconv.FormatInt(int64(val), 10))
+                return
+        }
+        return uint8(val)
+}
+
+// ReadInt16 read int16
+func (iter *Iterator) ReadInt16() (ret int16) {
+        c := iter.nextToken()
+        if c == '-' {
+                val := iter.readUint32(iter.readByte())
+                if val > math.MaxInt16+1 {
+                        iter.ReportError("ReadInt16", "overflow: "+strconv.FormatInt(int64(val), 10))
+                        return
+                }
+                return -int16(val)
+        }
+        val := iter.readUint32(c)
+        if val > math.MaxInt16 {
+                iter.ReportError("ReadInt16", "overflow: "+strconv.FormatInt(int64(val), 10))
+                return
+        }
+        return int16(val)
+}
+
+// ReadUint16 read uint16
+func (iter *Iterator) ReadUint16() (ret uint16) {
+        val := iter.readUint32(iter.nextToken())
+        if val > math.MaxUint16 {
+                iter.ReportError("ReadUint16", "overflow: "+strconv.FormatInt(int64(val), 10))
+                return
+        }
+        return uint16(val)
+}
+
+// ReadInt32 read int32
+func (iter *Iterator) ReadInt32() (ret int32) {
+        c := iter.nextToken()
+        if c == '-' {
+                val := iter.readUint32(iter.readByte())
+                if val > math.MaxInt32+1 {
+                        iter.ReportError("ReadInt32", "overflow: "+strconv.FormatInt(int64(val), 10))
+                        return
+                }
+                return -int32(val)
+        }
+        val := iter.readUint32(c)
+        if val > math.MaxInt32 {
+                iter.ReportError("ReadInt32", "overflow: "+strconv.FormatInt(int64(val), 10))
+                return
+        }
+        return int32(val)
+}
+
+// ReadUint32 read uint32
+func (iter *Iterator) ReadUint32() (ret uint32) {
+        return iter.readUint32(iter.nextToken())
+}
+
+func (iter *Iterator) readUint32(c byte) (ret uint32) {
+        ind := intDigits[c]
+        if ind == 0 {
+                iter.assertInteger()
+                return 0 // single zero
+        }
+        if ind == invalidCharForNumber {
+                iter.ReportError("readUint32", "unexpected character: "+string([]byte{byte(ind)}))
+                return
+        }
+        value := uint32(ind)
+        if iter.tail-iter.head > 10 {
+                i := iter.head
+                ind2 := intDigits[iter.buf[i]]
+                if ind2 == invalidCharForNumber {
+                        iter.head = i
+                        iter.assertInteger()
+                        return value
+                }
+                i++
+                ind3 := intDigits[iter.buf[i]]
+                if ind3 == invalidCharForNumber {
+                        iter.head = i
+                        iter.assertInteger()
+                        return value*10 + uint32(ind2)
+                }
+                //iter.head = i + 1
+                //value = value * 100 + uint32(ind2) * 10 + uint32(ind3)
+                i++
+                ind4 := intDigits[iter.buf[i]]
+                if ind4 == invalidCharForNumber {
+                        iter.head = i
+                        iter.assertInteger()
+                        return value*100 + uint32(ind2)*10 + uint32(ind3)
+                }
+                i++
+                ind5 := intDigits[iter.buf[i]]
+                if ind5 == invalidCharForNumber {
+                        iter.head = i
+                        iter.assertInteger()
+                        return value*1000 + uint32(ind2)*100 + uint32(ind3)*10 + uint32(ind4)
+                }
+                i++
+                ind6 := intDigits[iter.buf[i]]
+                if ind6 == invalidCharForNumber {
+                        iter.head = i
+                        iter.assertInteger()
+                        return value*10000 + uint32(ind2)*1000 + uint32(ind3)*100 + uint32(ind4)*10 + uint32(ind5)
+                }
+                i++
+                ind7 := intDigits[iter.buf[i]]
+                if ind7 == invalidCharForNumber {
+                        iter.head = i
+                        iter.assertInteger()
+                        return value*100000 + uint32(ind2)*10000 + uint32(ind3)*1000 + uint32(ind4)*100 + uint32(ind5)*10 + uint32(ind6)
+                }
+                i++
+                ind8 := intDigits[iter.buf[i]]
+                if ind8 == invalidCharForNumber {
+                        iter.head = i
+                        iter.assertInteger()
+                        return value*1000000 + uint32(ind2)*100000 + uint32(ind3)*10000 + uint32(ind4)*1000 + uint32(ind5)*100 + uint32(ind6)*10 + uint32(ind7)
+                }
+                i++
+                ind9 := intDigits[iter.buf[i]]
+                value = value*10000000 + uint32(ind2)*1000000 + uint32(ind3)*100000 + uint32(ind4)*10000 + uint32(ind5)*1000 + uint32(ind6)*100 + uint32(ind7)*10 + uint32(ind8)
+                iter.head = i
+                if ind9 == invalidCharForNumber {
+                        iter.assertInteger()
+                        return value
+                }
+        }
+        for {
+                for i := iter.head; i < iter.tail; i++ {
+                        ind = intDigits[iter.buf[i]]
+                        if ind == invalidCharForNumber {
+                                iter.head = i
+                                iter.assertInteger()
+                                return value
+                        }
+                        if value > uint32SafeToMultiply10 {
+                                value2 := (value << 3) + (value << 1) + uint32(ind)
+                                if value2 < value {
+                                        iter.ReportError("readUint32", "overflow")
+                                        return
+                                }
+                                value = value2
+                                continue
+                        }
+                        value = (value << 3) + (value << 1) + uint32(ind)
+                }
+                if !iter.loadMore() {
+                        iter.assertInteger()
+                        return value
+                }
+        }
+}
+
+// ReadInt64 read int64
+func (iter *Iterator) ReadInt64() (ret int64) {
+        c := iter.nextToken()
+        if c == '-' {
+                val := iter.readUint64(iter.readByte())
+                if val > math.MaxInt64+1 {
+                        iter.ReportError("ReadInt64", "overflow: "+strconv.FormatUint(uint64(val), 10))
+                        return
+                }
+                return -int64(val)
+        }
+        val := iter.readUint64(c)
+        if val > math.MaxInt64 {
+                iter.ReportError("ReadInt64", "overflow: "+strconv.FormatUint(uint64(val), 10))
+                return
+        }
+        return int64(val)
+}
+
+// ReadUint64 read uint64
+func (iter *Iterator) ReadUint64() uint64 {
+        return iter.readUint64(iter.nextToken())
+}
+
+func (iter *Iterator) readUint64(c byte) (ret uint64) {
+        ind := intDigits[c]
+        if ind == 0 {
+                iter.assertInteger()
+                return 0 // single zero
+        }
+        if ind == invalidCharForNumber {
+                iter.ReportError("readUint64", "unexpected character: "+string([]byte{byte(ind)}))
+                return
+        }
+        value := uint64(ind)
+        if iter.tail-iter.head > 10 {
+                i := iter.head
+                ind2 := intDigits[iter.buf[i]]
+                if ind2 == invalidCharForNumber {
+                        iter.head = i
+                        iter.assertInteger()
+                        return value
+                }
+                i++
+                ind3 := intDigits[iter.buf[i]]
+                if ind3 == invalidCharForNumber {
+                        iter.head = i
+                        iter.assertInteger()
+                        return value*10 + uint64(ind2)
+                }
+                //iter.head = i + 1
+                //value = value * 100 + uint32(ind2) * 10 + uint32(ind3)
+                i++
+                ind4 := intDigits[iter.buf[i]]
+                if ind4 == invalidCharForNumber {
+                        iter.head = i
+                        iter.assertInteger()
+                        return value*100 + uint64(ind2)*10 + uint64(ind3)
+                }
+                i++
+                ind5 := intDigits[iter.buf[i]]
+                if ind5 == invalidCharForNumber {
+                        iter.head = i
+                        iter.assertInteger()
+                        return value*1000 + uint64(ind2)*100 + uint64(ind3)*10 + uint64(ind4)
+                }
+                i++
+                ind6 := intDigits[iter.buf[i]]
+                if ind6 == invalidCharForNumber {
+                        iter.head = i
+                        iter.assertInteger()
+                        return value*10000 + uint64(ind2)*1000 + uint64(ind3)*100 + uint64(ind4)*10 + uint64(ind5)
+                }
+                i++
+                ind7 := intDigits[iter.buf[i]]
+                if ind7 == invalidCharForNumber {
+                        iter.head = i
+                        iter.assertInteger()
+                        return value*100000 + uint64(ind2)*10000 + uint64(ind3)*1000 + uint64(ind4)*100 + uint64(ind5)*10 + uint64(ind6)
+                }
+                i++
+                ind8 := intDigits[iter.buf[i]]
+                if ind8 == invalidCharForNumber {
+                        iter.head = i
+                        iter.assertInteger()
+                        return value*1000000 + uint64(ind2)*100000 + uint64(ind3)*10000 + uint64(ind4)*1000 + uint64(ind5)*100 + uint64(ind6)*10 + uint64(ind7)
+                }
+                i++
+                ind9 := intDigits[iter.buf[i]]
+                value = value*10000000 + uint64(ind2)*1000000 + uint64(ind3)*100000 + uint64(ind4)*10000 + uint64(ind5)*1000 + uint64(ind6)*100 + uint64(ind7)*10 + uint64(ind8)
+                iter.head = i
+                if ind9 == invalidCharForNumber {
+                        iter.assertInteger()
+                        return value
+                }
+        }
+        for {
+                for i := iter.head; i < iter.tail; i++ {
+                        ind = intDigits[iter.buf[i]]
+                        if ind == invalidCharForNumber {
+                                iter.head = i
+                                iter.assertInteger()
+                                return value
+                        }
+                        if value > uint64SafeToMultiple10 {
+                                value2 := (value << 3) + (value << 1) + uint64(ind)
+                                if value2 < value {
+                                        iter.ReportError("readUint64", "overflow")
+                                        return
+                                }
+                                value = value2
+                                continue
+                        }
+                        value = (value << 3) + (value << 1) + uint64(ind)
+                }
+                if !iter.loadMore() {
+                        iter.assertInteger()
+                        return value
+                }
+        }
+}
+
+func (iter *Iterator) assertInteger() {
+        if iter.head < iter.tail && iter.buf[iter.head] == '.' {
+                iter.ReportError("assertInteger", "can not decode float as int")
+        }
+}
diff --git a/vendor/github.com/json-iterator/go/iter_object.go b/vendor/github.com/json-iterator/go/iter_object.go
new file mode 100644
index 0000000..58ee89c
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/iter_object.go
@@ -0,0 +1,267 @@
+package jsoniter
+
+import (
+        "fmt"
+        "strings"
+)
+
+// ReadObject read one field from object.
+// If object ended, returns empty string.
+// Otherwise, returns the field name.
+func (iter *Iterator) ReadObject() (ret string) {
+        c := iter.nextToken()
+        switch c {
+        case 'n':
+                iter.skipThreeBytes('u', 'l', 'l')
+                return "" // null
+        case '{':
+                c = iter.nextToken()
+                if c == '"' {
+                        iter.unreadByte()
+                        field := iter.ReadString()
+                        c = iter.nextToken()
+                        if c != ':' {
+                                iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
+                        }
+                        return field
+                }
+                if c == '}' {
+                        return "" // end of object
+                }
+                iter.ReportError("ReadObject", `expect " after {, but found `+string([]byte{c}))
+                return
+        case ',':
+                field := iter.ReadString()
+                c = iter.nextToken()
+                if c != ':' {
+                        iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
+                }
+                return field
+        case '}':
+                return "" // end of object
+        default:
+                iter.ReportError("ReadObject", fmt.Sprintf(`expect { or , or } or n, but found %s`, string([]byte{c})))
+                return
+        }
+}
+
+// CaseInsensitive
+func (iter *Iterator) readFieldHash() int64 {
+        hash := int64(0x811c9dc5)
+        c := iter.nextToken()
+        if c != '"' {
+                iter.ReportError("readFieldHash", `expect ", but found `+string([]byte{c}))
+                return 0
+        }
+        for {
+                for i := iter.head; i < iter.tail; i++ {
+                        // require ascii string and no escape
+                        b := iter.buf[i]
+                        if b == '\\' {
+                                iter.head = i
+                                for _, b := range iter.readStringSlowPath() {
+                                        if 'A' <= b && b <= 'Z' && !iter.cfg.caseSensitive {
+                                                b += 'a' - 'A'
+                                        }
+                                        hash ^= int64(b)
+                                        hash *= 0x1000193
+                                }
+                                c = iter.nextToken()
+                                if c != ':' {
+                                        iter.ReportError("readFieldHash", `expect :, but found `+string([]byte{c}))
+                                        return 0
+                                }
+                                return hash
+                        }
+                        if b == '"' {
+                                iter.head = i + 1
+                                c = iter.nextToken()
+                                if c != ':' {
+                                        iter.ReportError("readFieldHash", `expect :, but found `+string([]byte{c}))
+                                        return 0
+                                }
+                                return hash
+                        }
+                        if 'A' <= b && b <= 'Z' && !iter.cfg.caseSensitive {
+                                b += 'a' - 'A'
+                        }
+                        hash ^= int64(b)
+                        hash *= 0x1000193
+                }
+                if !iter.loadMore() {
+                        iter.ReportError("readFieldHash", `incomplete field name`)
+                        return 0
+                }
+        }
+}
+
+func calcHash(str string, caseSensitive bool) int64 {
+        if !caseSensitive {
+                str = strings.ToLower(str)
+        }
+        hash := int64(0x811c9dc5)
+        for _, b := range []byte(str) {
+                hash ^= int64(b)
+                hash *= 0x1000193
+        }
+        return int64(hash)
+}
+
+// ReadObjectCB read object with callback, the key is ascii only and field name not copied
+func (iter *Iterator) ReadObjectCB(callback func(*Iterator, string) bool) bool {
+        c := iter.nextToken()
+        var field string
+        if c == '{' {
+                if !iter.incrementDepth() {
+                        return false
+                }
+                c = iter.nextToken()
+                if c == '"' {
+                        iter.unreadByte()
+                        field = iter.ReadString()
+                        c = iter.nextToken()
+                        if c != ':' {
+                                iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
+                        }
+                        if !callback(iter, field) {
+                                iter.decrementDepth()
+                                return false
+                        }
+                        c = iter.nextToken()
+                        for c == ',' {
+                                field = iter.ReadString()
+                                c = iter.nextToken()
+                                if c != ':' {
+                                        iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
+                                }
+                                if !callback(iter, field) {
+                                        iter.decrementDepth()
+                                        return false
+                                }
+                                c = iter.nextToken()
+                        }
+                        if c != '}' {
+                                iter.ReportError("ReadObjectCB", `object not ended with }`)
+                                iter.decrementDepth()
+                                return false
+                        }
+                        return iter.decrementDepth()
+                }
+                if c == '}' {
+                        return iter.decrementDepth()
+                }
+                iter.ReportError("ReadObjectCB", `expect " after {, but found `+string([]byte{c}))
+                iter.decrementDepth()
+                return false
+        }
+        if c == 'n' {
+                iter.skipThreeBytes('u', 'l', 'l')
+                return true // null
+        }
+        iter.ReportError("ReadObjectCB", `expect { or n, but found `+string([]byte{c}))
+        return false
+}
+
+// ReadMapCB read map with callback, the key can be any string
+func (iter *Iterator) ReadMapCB(callback func(*Iterator, string) bool) bool {
+        c := iter.nextToken()
+        if c == '{' {
+                if !iter.incrementDepth() {
+                        return false
+                }
+                c = iter.nextToken()
+                if c == '"' {
+                        iter.unreadByte()
+                        field := iter.ReadString()
+                        if iter.nextToken() != ':' {
+                                iter.ReportError("ReadMapCB", "expect : after object field, but found "+string([]byte{c}))
+                                iter.decrementDepth()
+                                return false
+                        }
+                        if !callback(iter, field) {
+                                iter.decrementDepth()
+                                return false
+                        }
+                        c = iter.nextToken()
+                        for c == ',' {
+                                field = iter.ReadString()
+                                if iter.nextToken() != ':' {
+                                        iter.ReportError("ReadMapCB", "expect : after object field, but found "+string([]byte{c}))
+                                        iter.decrementDepth()
+                                        return false
+                                }
+                                if !callback(iter, field) {
+                                        iter.decrementDepth()
+                                        return false
+                                }
+                                c = iter.nextToken()
+                        }
+                        if c != '}' {
+                                iter.ReportError("ReadMapCB", `object not ended with }`)
+                                iter.decrementDepth()
+                                return false
+                        }
+                        return iter.decrementDepth()
+                }
+                if c == '}' {
+                        return iter.decrementDepth()
+                }
+                iter.ReportError("ReadMapCB", `expect " after {, but found `+string([]byte{c}))
+                iter.decrementDepth()
+                return false
+        }
+        if c == 'n' {
+                iter.skipThreeBytes('u', 'l', 'l')
+                return true // null
+        }
+        iter.ReportError("ReadMapCB", `expect { or n, but found `+string([]byte{c}))
+        return false
+}
+
+func (iter *Iterator) readObjectStart() bool {
+        c := iter.nextToken()
+        if c == '{' {
+                c = iter.nextToken()
+                if c == '}' {
+                        return false
+                }
+                iter.unreadByte()
+                return true
+        } else if c == 'n' {
+                iter.skipThreeBytes('u', 'l', 'l')
+                return false
+        }
+        iter.ReportError("readObjectStart", "expect { or n, but found "+string([]byte{c}))
+        return false
+}
+
+func (iter *Iterator) readObjectFieldAsBytes() (ret []byte) {
+        str := iter.ReadStringAsSlice()
+        if iter.skipWhitespacesWithoutLoadMore() {
+                if ret == nil {
+                        ret = make([]byte, len(str))
+                        copy(ret, str)
+                }
+                if !iter.loadMore() {
+                        return
+                }
+        }
+        if iter.buf[iter.head] != ':' {
+                iter.ReportError("readObjectFieldAsBytes", "expect : after object field, but found "+string([]byte{iter.buf[iter.head]}))
+                return
+        }
+        iter.head++
+        if iter.skipWhitespacesWithoutLoadMore() {
+                if ret == nil {
+                        ret = make([]byte, len(str))
+                        copy(ret, str)
+                }
+                if !iter.loadMore() {
+                        return
+                }
+        }
+        if ret == nil {
+                return str
+        }
+        return ret
+}
diff --git a/vendor/github.com/json-iterator/go/iter_skip.go b/vendor/github.com/json-iterator/go/iter_skip.go
new file mode 100644
index 0000000..e91eefb
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/iter_skip.go
@@ -0,0 +1,130 @@
+package jsoniter
+
+import "fmt"
+
+// ReadNil reads a json object as nil and
+// returns whether it's a nil or not
+func (iter *Iterator) ReadNil() (ret bool) {
+        c := iter.nextToken()
+        if c == 'n' {
+                iter.skipThreeBytes('u', 'l', 'l') // null
+                return true
+        }
+        iter.unreadByte()
+        return false
+}
+
+// ReadBool reads a json object as BoolValue
+func (iter *Iterator) ReadBool() (ret bool) {
+        c := iter.nextToken()
+        if c == 't' {
+                iter.skipThreeBytes('r', 'u', 'e')
+                return true
+        }
+        if c == 'f' {
+                iter.skipFourBytes('a', 'l', 's', 'e')
+                return false
+        }
+        iter.ReportError("ReadBool", "expect t or f, but found "+string([]byte{c}))
+        return
+}
+
+// SkipAndReturnBytes skip next JSON element, and return its content as []byte.
+// The []byte can be kept, it is a copy of data.
+func (iter *Iterator) SkipAndReturnBytes() []byte {
+        iter.startCapture(iter.head)
+        iter.Skip()
+        return iter.stopCapture()
+}
+
+// SkipAndAppendBytes skips next JSON element and appends its content to
+// buffer, returning the result.
+func (iter *Iterator) SkipAndAppendBytes(buf []byte) []byte {
+        iter.startCaptureTo(buf, iter.head)
+        iter.Skip()
+        return iter.stopCapture()
+}
+
+func (iter *Iterator) startCaptureTo(buf []byte, captureStartedAt int) {
+        if iter.captured != nil {
+                panic("already in capture mode")
+        }
+        iter.captureStartedAt = captureStartedAt
+        iter.captured = buf
+}
+
+func (iter *Iterator) startCapture(captureStartedAt int) {
+        iter.startCaptureTo(make([]byte, 0, 32), captureStartedAt)
+}
+
+func (iter *Iterator) stopCapture() []byte {
+        if iter.captured == nil {
+                panic("not in capture mode")
+        }
+        captured := iter.captured
+        remaining := iter.buf[iter.captureStartedAt:iter.head]
+        iter.captureStartedAt = -1
+        iter.captured = nil
+        return append(captured, remaining...)
+}
+
+// Skip skips a json object and positions to relatively the next json object
+func (iter *Iterator) Skip() {
+        c := iter.nextToken()
+        switch c {
+        case '"':
+                iter.skipString()
+        case 'n':
+                iter.skipThreeBytes('u', 'l', 'l') // null
+        case 't':
+                iter.skipThreeBytes('r', 'u', 'e') // true
+        case 'f':
+                iter.skipFourBytes('a', 'l', 's', 'e') // false
+        case '0':
+                iter.unreadByte()
+                iter.ReadFloat32()
+        case '-', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+                iter.skipNumber()
+        case '[':
+                iter.skipArray()
+        case '{':
+                iter.skipObject()
+        default:
+                iter.ReportError("Skip", fmt.Sprintf("do not know how to skip: %v", c))
+                return
+        }
+}
+
+func (iter *Iterator) skipFourBytes(b1, b2, b3, b4 byte) {
+        if iter.readByte() != b1 {
+                iter.ReportError("skipFourBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3, b4})))
+                return
+        }
+        if iter.readByte() != b2 {
+                iter.ReportError("skipFourBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3, b4})))
+                return
+        }
+        if iter.readByte() != b3 {
+                iter.ReportError("skipFourBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3, b4})))
+                return
+        }
+        if iter.readByte() != b4 {
+                iter.ReportError("skipFourBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3, b4})))
+                return
+        }
+}
+
+func (iter *Iterator) skipThreeBytes(b1, b2, b3 byte) {
+        if iter.readByte() != b1 {
+                iter.ReportError("skipThreeBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3})))
+                return
+        }
+        if iter.readByte() != b2 {
+                iter.ReportError("skipThreeBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3})))
+                return
+        }
+        if iter.readByte() != b3 {
+                iter.ReportError("skipThreeBytes", fmt.Sprintf("expect %s", string([]byte{b1, b2, b3})))
+                return
+        }
+}
diff --git a/vendor/github.com/json-iterator/go/iter_skip_sloppy.go b/vendor/github.com/json-iterator/go/iter_skip_sloppy.go
new file mode 100644
index 0000000..9303de4
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/iter_skip_sloppy.go
@@ -0,0 +1,163 @@
+//+build jsoniter_sloppy
+
+package jsoniter
+
+// sloppy but faster implementation, do not validate the input json
+
+func (iter *Iterator) skipNumber() {
+        for {
+                for i := iter.head; i < iter.tail; i++ {
+                        c := iter.buf[i]
+                        switch c {
+                        case ' ', '\n', '\r', '\t', ',', '}', ']':
+                                iter.head = i
+                                return
+                        }
+                }
+                if !iter.loadMore() {
+                        return
+                }
+        }
+}
+
+func (iter *Iterator) skipArray() {
+        level := 1
+        if !iter.incrementDepth() {
+                return
+        }
+        for {
+                for i := iter.head; i < iter.tail; i++ {
+                        switch iter.buf[i] {
+                        case '"': // If inside string, skip it
+                                iter.head = i + 1
+                                iter.skipString()
+                                i = iter.head - 1 // it will be i++ soon
+                        case '[': // If open symbol, increase level
+                                level++
+                                if !iter.incrementDepth() {
+                                        return
+                                }
+                        case ']': // If close symbol, increase level
+                                level--
+                                if !iter.decrementDepth() {
+                                        return
+                                }
+
+                                // If we have returned to the original level, we're done
+                                if level == 0 {
+                                        iter.head = i + 1
+                                        return
+                                }
+                        }
+                }
+                if !iter.loadMore() {
+                        iter.ReportError("skipObject", "incomplete array")
+                        return
+                }
+        }
+}
+
+func (iter *Iterator) skipObject() {
+        level := 1
+        if !iter.incrementDepth() {
+                return
+        }
+
+        for {
+                for i := iter.head; i < iter.tail; i++ {
+                        switch iter.buf[i] {
+                        case '"': // If inside string, skip it
+                                iter.head = i + 1
+                                iter.skipString()
+                                i = iter.head - 1 // it will be i++ soon
+                        case '{': // If open symbol, increase level
+                                level++
+                                if !iter.incrementDepth() {
+                                        return
+                                }
+                        case '}': // If close symbol, increase level
+                                level--
+                                if !iter.decrementDepth() {
+                                        return
+                                }
+
+                                // If we have returned to the original level, we're done
+                                if level == 0 {
+                                        iter.head = i + 1
+                                        return
+                                }
+                        }
+                }
+                if !iter.loadMore() {
+                        iter.ReportError("skipObject", "incomplete object")
+                        return
+                }
+        }
+}
+
+func (iter *Iterator) skipString() {
+        for {
+                end, escaped := iter.findStringEnd()
+                if end == -1 {
+                        if !iter.loadMore() {
+                                iter.ReportError("skipString", "incomplete string")
+                                return
+                        }
+                        if escaped {
+                                iter.head = 1 // skip the first char as last char read is \
+                        }
+                } else {
+                        iter.head = end
+                        return
+                }
+        }
+}
+
+// adapted from: https://github.com/buger/jsonparser/blob/master/parser.go
+// Tries to find the end of string
+// Support if string contains escaped quote symbols.
+func (iter *Iterator) findStringEnd() (int, bool) {
+        escaped := false
+        for i := iter.head; i < iter.tail; i++ {
+                c := iter.buf[i]
+                if c == '"' {
+                        if !escaped {
+                                return i + 1, false
+                        }
+                        j := i - 1
+                        for {
+                                if j < iter.head || iter.buf[j] != '\\' {
+                                        // even number of backslashes
+                                        // either end of buffer, or " found
+                                        return i + 1, true
+                                }
+                                j--
+                                if j < iter.head || iter.buf[j] != '\\' {
+                                        // odd number of backslashes
+                                        // it is \" or \\\"
+                                        break
+                                }
+                                j--
+                        }
+                } else if c == '\\' {
+                        escaped = true
+                }
+        }
+        j := iter.tail - 1
+        for {
+                if j < iter.head || iter.buf[j] != '\\' {
+                        // even number of backslashes
+                        // either end of buffer, or " found
+                        return -1, false // do not end with \
+                }
+                j--
+                if j < iter.head || iter.buf[j] != '\\' {
+                        // odd number of backslashes
+                        // it is \" or \\\"
+                        break
+                }
+                j--
+
+        }
+        return -1, true // end with \
+}
diff --git a/vendor/github.com/json-iterator/go/iter_skip_strict.go b/vendor/github.com/json-iterator/go/iter_skip_strict.go
new file mode 100644
index 0000000..6cf66d0
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/iter_skip_strict.go
@@ -0,0 +1,99 @@
+//+build !jsoniter_sloppy
+
+package jsoniter
+
+import (
+        "fmt"
+        "io"
+)
+
+func (iter *Iterator) skipNumber() {
+        if !iter.trySkipNumber() {
+                iter.unreadByte()
+                if iter.Error != nil && iter.Error != io.EOF {
+                        return
+                }
+                iter.ReadFloat64()
+                if iter.Error != nil && iter.Error != io.EOF {
+                        iter.Error = nil
+                        iter.ReadBigFloat()
+                }
+        }
+}
+
+func (iter *Iterator) trySkipNumber() bool {
+        dotFound := false
+        for i := iter.head; i < iter.tail; i++ {
+                c := iter.buf[i]
+                switch c {
+                case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+                case '.':
+                        if dotFound {
+                                iter.ReportError("validateNumber", `more than one dot found in number`)
+                                return true // already failed
+                        }
+                        if i+1 == iter.tail {
+                                return false
+                        }
+                        c = iter.buf[i+1]
+                        switch c {
+                        case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+                        default:
+                                iter.ReportError("validateNumber", `missing digit after dot`)
+                                return true // already failed
+                        }
+                        dotFound = true
+                default:
+                        switch c {
+                        case ',', ']', '}', ' ', '\t', '\n', '\r':
+                                if iter.head == i {
+                                        return false // if - without following digits
+                                }
+                                iter.head = i
+                                return true // must be valid
+                        }
+                        return false // may be invalid
+                }
+        }
+        return false
+}
+
+func (iter *Iterator) skipString() {
+        if !iter.trySkipString() {
+                iter.unreadByte()
+                iter.ReadString()
+        }
+}
+
+func (iter *Iterator) trySkipString() bool {
+        for i := iter.head; i < iter.tail; i++ {
+                c := iter.buf[i]
+                if c == '"' {
+                        iter.head = i + 1
+                        return true // valid
+                } else if c == '\\' {
+                        return false
+                } else if c < ' ' {
+                        iter.ReportError("trySkipString",
+                                fmt.Sprintf(`invalid control character found: %d`, c))
+                        return true // already failed
+                }
+        }
+        return false
+}
+
+func (iter *Iterator) skipObject() {
+        iter.unreadByte()
+        iter.ReadObjectCB(func(iter *Iterator, field string) bool {
+                iter.Skip()
+                return true
+        })
+}
+
+func (iter *Iterator) skipArray() {
+        iter.unreadByte()
+        iter.ReadArrayCB(func(iter *Iterator) bool {
+                iter.Skip()
+                return true
+        })
+}
diff --git a/vendor/github.com/json-iterator/go/iter_str.go b/vendor/github.com/json-iterator/go/iter_str.go
new file mode 100644
index 0000000..adc487e
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/iter_str.go
@@ -0,0 +1,215 @@
+package jsoniter
+
+import (
+        "fmt"
+        "unicode/utf16"
+)
+
+// ReadString read string from iterator
+func (iter *Iterator) ReadString() (ret string) {
+        c := iter.nextToken()
+        if c == '"' {
+                for i := iter.head; i < iter.tail; i++ {
+                        c := iter.buf[i]
+                        if c == '"' {
+                                ret = string(iter.buf[iter.head:i])
+                                iter.head = i + 1
+                                return ret
+                        } else if c == '\\' {
+                                break
+                        } else if c < ' ' {
+                                iter.ReportError("ReadString",
+                                        fmt.Sprintf(`invalid control character found: %d`, c))
+                                return
+                        }
+                }
+                return iter.readStringSlowPath()
+        } else if c == 'n' {
+                iter.skipThreeBytes('u', 'l', 'l')
+                return ""
+        }
+        iter.ReportError("ReadString", `expects " or n, but found `+string([]byte{c}))
+        return
+}
+
+func (iter *Iterator) readStringSlowPath() (ret string) {
+        var str []byte
+        var c byte
+        for iter.Error == nil {
+                c = iter.readByte()
+                if c == '"' {
+                        return string(str)
+                }
+                if c == '\\' {
+                        c = iter.readByte()
+                        str = iter.readEscapedChar(c, str)
+                } else {
+                        str = append(str, c)
+                }
+        }
+        iter.ReportError("readStringSlowPath", "unexpected end of input")
+        return
+}
+
+func (iter *Iterator) readEscapedChar(c byte, str []byte) []byte {
+        switch c {
+        case 'u':
+                r := iter.readU4()
+                if utf16.IsSurrogate(r) {
+                        c = iter.readByte()
+                        if iter.Error != nil {
+                                return nil
+                        }
+                        if c != '\\' {
+                                iter.unreadByte()
+                                str = appendRune(str, r)
+                                return str
+                        }
+                        c = iter.readByte()
+                        if iter.Error != nil {
+                                return nil
+                        }
+                        if c != 'u' {
+                                str = appendRune(str, r)
+                                return iter.readEscapedChar(c, str)
+                        }
+                        r2 := iter.readU4()
+                        if iter.Error != nil {
+                                return nil
+                        }
+                        combined := utf16.DecodeRune(r, r2)
+                        if combined == '\uFFFD' {
+                                str = appendRune(str, r)
+                                str = appendRune(str, r2)
+                        } else {
+                                str = appendRune(str, combined)
+                        }
+                } else {
+                        str = appendRune(str, r)
+                }
+        case '"':
+                str = append(str, '"')
+        case '\\':
+                str = append(str, '\\')
+        case '/':
+                str = append(str, '/')
+        case 'b':
+                str = append(str, '\b')
+        case 'f':
+                str = append(str, '\f')
+        case 'n':
+                str = append(str, '\n')
+        case 'r':
+                str = append(str, '\r')
+        case 't':
+                str = append(str, '\t')
+        default:
+                iter.ReportError("readEscapedChar",
+                        `invalid escape char after \`)
+                return nil
+        }
+        return str
+}
+
+// ReadStringAsSlice read string from iterator without copying into string form.
+// The []byte can not be kept, as it will change after next iterator call.
+func (iter *Iterator) ReadStringAsSlice() (ret []byte) {
+        c := iter.nextToken()
+        if c == '"' {
+                for i := iter.head; i < iter.tail; i++ {
+                        // require ascii string and no escape
+                        // for: field name, base64, number
+                        if iter.buf[i] == '"' {
+                                // fast path: reuse the underlying buffer
+                                ret = iter.buf[iter.head:i]
+                                iter.head = i + 1
+                                return ret
+                        }
+                }
+                readLen := iter.tail - iter.head
+                copied := make([]byte, readLen, readLen*2)
+                copy(copied, iter.buf[iter.head:iter.tail])
+                iter.head = iter.tail
+                for iter.Error == nil {
+                        c := iter.readByte()
+                        if c == '"' {
+                                return copied
+                        }
+                        copied = append(copied, c)
+                }
+                return copied
+        }
+        iter.ReportError("ReadStringAsSlice", `expects " or n, but found `+string([]byte{c}))
+        return
+}
+
+func (iter *Iterator) readU4() (ret rune) {
+        for i := 0; i < 4; i++ {
+                c := iter.readByte()
+                if iter.Error != nil {
+                        return
+                }
+                if c >= '0' && c <= '9' {
+                        ret = ret*16 + rune(c-'0')
+                } else if c >= 'a' && c <= 'f' {
+                        ret = ret*16 + rune(c-'a'+10)
+                } else if c >= 'A' && c <= 'F' {
+                        ret = ret*16 + rune(c-'A'+10)
+                } else {
+                        iter.ReportError("readU4", "expects 0~9 or a~f, but found "+string([]byte{c}))
+                        return
+                }
+        }
+        return ret
+}
+
+const (
+        t1 = 0x00 // 0000 0000
+        tx = 0x80 // 1000 0000
+        t2 = 0xC0 // 1100 0000
+        t3 = 0xE0 // 1110 0000
+        t4 = 0xF0 // 1111 0000
+        t5 = 0xF8 // 1111 1000
+
+        maskx = 0x3F // 0011 1111
+        mask2 = 0x1F // 0001 1111
+        mask3 = 0x0F // 0000 1111
+        mask4 = 0x07 // 0000 0111
+
+        rune1Max = 1<<7 - 1
+        rune2Max = 1<<11 - 1
+        rune3Max = 1<<16 - 1
+
+        surrogateMin = 0xD800
+        surrogateMax = 0xDFFF
+
+        maxRune   = '\U0010FFFF' // Maximum valid Unicode code point.
+        runeError = '\uFFFD'     // the "error" Rune or "Unicode replacement character"
+)
+
+func appendRune(p []byte, r rune) []byte {
+        // Negative values are erroneous. Making it unsigned addresses the problem.
+        switch i := uint32(r); {
+        case i <= rune1Max:
+                p = append(p, byte(r))
+                return p
+        case i <= rune2Max:
+                p = append(p, t2|byte(r>>6))
+                p = append(p, tx|byte(r)&maskx)
+                return p
+        case i > maxRune, surrogateMin <= i && i <= surrogateMax:
+                r = runeError
+                fallthrough
+        case i <= rune3Max:
+                p = append(p, t3|byte(r>>12))
+                p = append(p, tx|byte(r>>6)&maskx)
+                p = append(p, tx|byte(r)&maskx)
+                return p
+        default:
+                p = append(p, t4|byte(r>>18))
+                p = append(p, tx|byte(r>>12)&maskx)
+                p = append(p, tx|byte(r>>6)&maskx)
+                p = append(p, tx|byte(r)&maskx)
+                return p
+        }
+}
diff --git a/vendor/github.com/json-iterator/go/jsoniter.go b/vendor/github.com/json-iterator/go/jsoniter.go
new file mode 100644
index 0000000..c2934f9
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/jsoniter.go
@@ -0,0 +1,18 @@
+// Package jsoniter implements encoding and decoding of JSON as defined in
+// RFC 4627 and provides interfaces with identical syntax of standard lib encoding/json.
+// Converting from encoding/json to jsoniter is no more than replacing the package with jsoniter
+// and variable type declarations (if any).
+// jsoniter interfaces gives 100% compatibility with code using standard lib.
+//
+// "JSON and Go"
+// (https://golang.org/doc/articles/json_and_go.html)
+// gives a description of how Marshal/Unmarshal operate
+// between arbitrary or predefined json objects and bytes,
+// and it applies to jsoniter.Marshal/Unmarshal as well.
+//
+// Besides, jsoniter.Iterator provides a different set of interfaces
+// iterating given bytes/string/reader
+// and yielding parsed elements one by one.
+// This set of interfaces reads input as required and gives
+// better performance.
+package jsoniter
diff --git a/vendor/github.com/json-iterator/go/pool.go b/vendor/github.com/json-iterator/go/pool.go
new file mode 100644
index 0000000..e2389b5
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/pool.go
@@ -0,0 +1,42 @@
+package jsoniter
+
+import (
+        "io"
+)
+
+// IteratorPool a thread safe pool of iterators with same configuration
+type IteratorPool interface {
+        BorrowIterator(data []byte) *Iterator
+        ReturnIterator(iter *Iterator)
+}
+
+// StreamPool a thread safe pool of streams with same configuration
+type StreamPool interface {
+        BorrowStream(writer io.Writer) *Stream
+        ReturnStream(stream *Stream)
+}
+
+func (cfg *frozenConfig) BorrowStream(writer io.Writer) *Stream {
+        stream := cfg.streamPool.Get().(*Stream)
+        stream.Reset(writer)
+        return stream
+}
+
+func (cfg *frozenConfig) ReturnStream(stream *Stream) {
+        stream.out = nil
+        stream.Error = nil
+        stream.Attachment = nil
+        cfg.streamPool.Put(stream)
+}
+
+func (cfg *frozenConfig) BorrowIterator(data []byte) *Iterator {
+        iter := cfg.iteratorPool.Get().(*Iterator)
+        iter.ResetBytes(data)
+        return iter
+}
+
+func (cfg *frozenConfig) ReturnIterator(iter *Iterator) {
+        iter.Error = nil
+        iter.Attachment = nil
+        cfg.iteratorPool.Put(iter)
+}
diff --git a/vendor/github.com/json-iterator/go/reflect.go b/vendor/github.com/json-iterator/go/reflect.go
new file mode 100644
index 0000000..39acb32
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/reflect.go
@@ -0,0 +1,337 @@
+package jsoniter
+
+import (
+        "fmt"
+        "reflect"
+        "unsafe"
+
+        "github.com/modern-go/reflect2"
+)
+
+// ValDecoder is an internal type registered to cache as needed.
+// Don't confuse jsoniter.ValDecoder with json.Decoder.
+// For json.Decoder's adapter, refer to jsoniter.AdapterDecoder(todo link).
+//
+// Reflection on type to create decoders, which is then cached
+// Reflection on value is avoided as we can, as the reflect.Value itself will allocate, with following exceptions
+// 1. create instance of new value, for example *int will need a int to be allocated
+// 2. append to slice, if the existing cap is not enough, allocate will be done using Reflect.New
+// 3. assignment to map, both key and value will be reflect.Value
+// For a simple struct binding, it will be reflect.Value free and allocation free
+type ValDecoder interface {
+        Decode(ptr unsafe.Pointer, iter *Iterator)
+}
+
+// ValEncoder is an internal type registered to cache as needed.
+// Don't confuse jsoniter.ValEncoder with json.Encoder.
+// For json.Encoder's adapter, refer to jsoniter.AdapterEncoder(todo godoc link).
+type ValEncoder interface {
+        IsEmpty(ptr unsafe.Pointer) bool
+        Encode(ptr unsafe.Pointer, stream *Stream)
+}
+
+type checkIsEmpty interface {
+        IsEmpty(ptr unsafe.Pointer) bool
+}
+
+type ctx struct {
+        *frozenConfig
+        prefix   string
+        encoders map[reflect2.Type]ValEncoder
+        decoders map[reflect2.Type]ValDecoder
+}
+
+func (b *ctx) caseSensitive() bool {
+        if b.frozenConfig == nil {
+                // default is case-insensitive
+                return false
+        }
+        return b.frozenConfig.caseSensitive
+}
+
+func (b *ctx) append(prefix string) *ctx {
+        return &ctx{
+                frozenConfig: b.frozenConfig,
+                prefix:       b.prefix + " " + prefix,
+                encoders:     b.encoders,
+                decoders:     b.decoders,
+        }
+}
+
+// ReadVal copy the underlying JSON into go interface, same as json.Unmarshal
+func (iter *Iterator) ReadVal(obj interface{}) {
+        depth := iter.depth
+        cacheKey := reflect2.RTypeOf(obj)
+        decoder := iter.cfg.getDecoderFromCache(cacheKey)
+        if decoder == nil {
+                typ := reflect2.TypeOf(obj)
+                if typ == nil || typ.Kind() != reflect.Ptr {
+                        iter.ReportError("ReadVal", "can only unmarshal into pointer")
+                        return
+                }
+                decoder = iter.cfg.DecoderOf(typ)
+        }
+        ptr := reflect2.PtrOf(obj)
+        if ptr == nil {
+                iter.ReportError("ReadVal", "can not read into nil pointer")
+                return
+        }
+        decoder.Decode(ptr, iter)
+        if iter.depth != depth {
+                iter.ReportError("ReadVal", "unexpected mismatched nesting")
+                return
+        }
+}
+
+// WriteVal copy the go interface into underlying JSON, same as json.Marshal
+func (stream *Stream) WriteVal(val interface{}) {
+        if nil == val {
+                stream.WriteNil()
+                return
+        }
+        cacheKey := reflect2.RTypeOf(val)
+        encoder := stream.cfg.getEncoderFromCache(cacheKey)
+        if encoder == nil {
+                typ := reflect2.TypeOf(val)
+                encoder = stream.cfg.EncoderOf(typ)
+        }
+        encoder.Encode(reflect2.PtrOf(val), stream)
+}
+
+func (cfg *frozenConfig) DecoderOf(typ reflect2.Type) ValDecoder {
+        cacheKey := typ.RType()
+        decoder := cfg.getDecoderFromCache(cacheKey)
+        if decoder != nil {
+                return decoder
+        }
+        ctx := &ctx{
+                frozenConfig: cfg,
+                prefix:       "",
+                decoders:     map[reflect2.Type]ValDecoder{},
+                encoders:     map[reflect2.Type]ValEncoder{},
+        }
+        ptrType := typ.(*reflect2.UnsafePtrType)
+        decoder = decoderOfType(ctx, ptrType.Elem())
+        cfg.addDecoderToCache(cacheKey, decoder)
+        return decoder
+}
+
+func decoderOfType(ctx *ctx, typ reflect2.Type) ValDecoder {
+        decoder := getTypeDecoderFromExtension(ctx, typ)
+        if decoder != nil {
+                return decoder
+        }
+        decoder = createDecoderOfType(ctx, typ)
+        for _, extension := range extensions {
+                decoder = extension.DecorateDecoder(typ, decoder)
+        }
+        decoder = ctx.decoderExtension.DecorateDecoder(typ, decoder)
+        for _, extension := range ctx.extraExtensions {
+                decoder = extension.DecorateDecoder(typ, decoder)
+        }
+        return decoder
+}
+
+func createDecoderOfType(ctx *ctx, typ reflect2.Type) ValDecoder {
+        decoder := ctx.decoders[typ]
+        if decoder != nil {
+                return decoder
+        }
+        placeholder := &placeholderDecoder{}
+        ctx.decoders[typ] = placeholder
+        decoder = _createDecoderOfType(ctx, typ)
+        placeholder.decoder = decoder
+        return decoder
+}
+
+func _createDecoderOfType(ctx *ctx, typ reflect2.Type) ValDecoder {
+        decoder := createDecoderOfJsonRawMessage(ctx, typ)
+        if decoder != nil {
+                return decoder
+        }
+        decoder = createDecoderOfJsonNumber(ctx, typ)
+        if decoder != nil {
+                return decoder
+        }
+        decoder = createDecoderOfMarshaler(ctx, typ)
+        if decoder != nil {
+                return decoder
+        }
+        decoder = createDecoderOfAny(ctx, typ)
+        if decoder != nil {
+                return decoder
+        }
+        decoder = createDecoderOfNative(ctx, typ)
+        if decoder != nil {
+                return decoder
+        }
+        switch typ.Kind() {
+        case reflect.Interface:
+                ifaceType, isIFace := typ.(*reflect2.UnsafeIFaceType)
+                if isIFace {
+                        return &ifaceDecoder{valType: ifaceType}
+                }
+                return &efaceDecoder{}
+        case reflect.Struct:
+                return decoderOfStruct(ctx, typ)
+        case reflect.Array:
+                return decoderOfArray(ctx, typ)
+        case reflect.Slice:
+                return decoderOfSlice(ctx, typ)
+        case reflect.Map:
+                return decoderOfMap(ctx, typ)
+        case reflect.Ptr:
+                return decoderOfOptional(ctx, typ)
+        default:
+                return &lazyErrorDecoder{err: fmt.Errorf("%s%s is unsupported type", ctx.prefix, typ.String())}
+        }
+}
+
+func (cfg *frozenConfig) EncoderOf(typ reflect2.Type) ValEncoder {
+        cacheKey := typ.RType()
+        encoder := cfg.getEncoderFromCache(cacheKey)
+        if encoder != nil {
+                return encoder
+        }
+        ctx := &ctx{
+                frozenConfig: cfg,
+                prefix:       "",
+                decoders:     map[reflect2.Type]ValDecoder{},
+                encoders:     map[reflect2.Type]ValEncoder{},
+        }
+        encoder = encoderOfType(ctx, typ)
+        if typ.LikePtr() {
+                encoder = &onePtrEncoder{encoder}
+        }
+        cfg.addEncoderToCache(cacheKey, encoder)
+        return encoder
+}
+
+type onePtrEncoder struct {
+        encoder ValEncoder
+}
+
+func (encoder *onePtrEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return encoder.encoder.IsEmpty(unsafe.Pointer(&ptr))
+}
+
+func (encoder *onePtrEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        encoder.encoder.Encode(unsafe.Pointer(&ptr), stream)
+}
+
+func encoderOfType(ctx *ctx, typ reflect2.Type) ValEncoder {
+        encoder := getTypeEncoderFromExtension(ctx, typ)
+        if encoder != nil {
+                return encoder
+        }
+        encoder = createEncoderOfType(ctx, typ)
+        for _, extension := range extensions {
+                encoder = extension.DecorateEncoder(typ, encoder)
+        }
+        encoder = ctx.encoderExtension.DecorateEncoder(typ, encoder)
+        for _, extension := range ctx.extraExtensions {
+                encoder = extension.DecorateEncoder(typ, encoder)
+        }
+        return encoder
+}
+
+func createEncoderOfType(ctx *ctx, typ reflect2.Type) ValEncoder {
+        encoder := ctx.encoders[typ]
+        if encoder != nil {
+                return encoder
+        }
+        placeholder := &placeholderEncoder{}
+        ctx.encoders[typ] = placeholder
+        encoder = _createEncoderOfType(ctx, typ)
+        placeholder.encoder = encoder
+        return encoder
+}
+func _createEncoderOfType(ctx *ctx, typ reflect2.Type) ValEncoder {
+        encoder := createEncoderOfJsonRawMessage(ctx, typ)
+        if encoder != nil {
+                return encoder
+        }
+        encoder = createEncoderOfJsonNumber(ctx, typ)
+        if encoder != nil {
+                return encoder
+        }
+        encoder = createEncoderOfMarshaler(ctx, typ)
+        if encoder != nil {
+                return encoder
+        }
+        encoder = createEncoderOfAny(ctx, typ)
+        if encoder != nil {
+                return encoder
+        }
+        encoder = createEncoderOfNative(ctx, typ)
+        if encoder != nil {
+                return encoder
+        }
+        kind := typ.Kind()
+        switch kind {
+        case reflect.Interface:
+                return &dynamicEncoder{typ}
+        case reflect.Struct:
+                return encoderOfStruct(ctx, typ)
+        case reflect.Array:
+                return encoderOfArray(ctx, typ)
+        case reflect.Slice:
+                return encoderOfSlice(ctx, typ)
+        case reflect.Map:
+                return encoderOfMap(ctx, typ)
+        case reflect.Ptr:
+                return encoderOfOptional(ctx, typ)
+        default:
+                return &lazyErrorEncoder{err: fmt.Errorf("%s%s is unsupported type", ctx.prefix, typ.String())}
+        }
+}
+
+type lazyErrorDecoder struct {
+        err error
+}
+
+func (decoder *lazyErrorDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if iter.WhatIsNext() != NilValue {
+                if iter.Error == nil {
+                        iter.Error = decoder.err
+                }
+        } else {
+                iter.Skip()
+        }
+}
+
+type lazyErrorEncoder struct {
+        err error
+}
+
+func (encoder *lazyErrorEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        if ptr == nil {
+                stream.WriteNil()
+        } else if stream.Error == nil {
+                stream.Error = encoder.err
+        }
+}
+
+func (encoder *lazyErrorEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return false
+}
+
+type placeholderDecoder struct {
+        decoder ValDecoder
+}
+
+func (decoder *placeholderDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        decoder.decoder.Decode(ptr, iter)
+}
+
+type placeholderEncoder struct {
+        encoder ValEncoder
+}
+
+func (encoder *placeholderEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        encoder.encoder.Encode(ptr, stream)
+}
+
+func (encoder *placeholderEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return encoder.encoder.IsEmpty(ptr)
+}
diff --git a/vendor/github.com/json-iterator/go/reflect_array.go b/vendor/github.com/json-iterator/go/reflect_array.go
new file mode 100644
index 0000000..13a0b7b
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/reflect_array.go
@@ -0,0 +1,104 @@
+package jsoniter
+
+import (
+        "fmt"
+        "github.com/modern-go/reflect2"
+        "io"
+        "unsafe"
+)
+
+func decoderOfArray(ctx *ctx, typ reflect2.Type) ValDecoder {
+        arrayType := typ.(*reflect2.UnsafeArrayType)
+        decoder := decoderOfType(ctx.append("[arrayElem]"), arrayType.Elem())
+        return &arrayDecoder{arrayType, decoder}
+}
+
+func encoderOfArray(ctx *ctx, typ reflect2.Type) ValEncoder {
+        arrayType := typ.(*reflect2.UnsafeArrayType)
+        if arrayType.Len() == 0 {
+                return emptyArrayEncoder{}
+        }
+        encoder := encoderOfType(ctx.append("[arrayElem]"), arrayType.Elem())
+        return &arrayEncoder{arrayType, encoder}
+}
+
+type emptyArrayEncoder struct{}
+
+func (encoder emptyArrayEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteEmptyArray()
+}
+
+func (encoder emptyArrayEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return true
+}
+
+type arrayEncoder struct {
+        arrayType   *reflect2.UnsafeArrayType
+        elemEncoder ValEncoder
+}
+
+func (encoder *arrayEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteArrayStart()
+        elemPtr := unsafe.Pointer(ptr)
+        encoder.elemEncoder.Encode(elemPtr, stream)
+        for i := 1; i < encoder.arrayType.Len(); i++ {
+                stream.WriteMore()
+                elemPtr = encoder.arrayType.UnsafeGetIndex(ptr, i)
+                encoder.elemEncoder.Encode(elemPtr, stream)
+        }
+        stream.WriteArrayEnd()
+        if stream.Error != nil && stream.Error != io.EOF {
+                stream.Error = fmt.Errorf("%v: %s", encoder.arrayType, stream.Error.Error())
+        }
+}
+
+func (encoder *arrayEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return false
+}
+
+type arrayDecoder struct {
+        arrayType   *reflect2.UnsafeArrayType
+        elemDecoder ValDecoder
+}
+
+func (decoder *arrayDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        decoder.doDecode(ptr, iter)
+        if iter.Error != nil && iter.Error != io.EOF {
+                iter.Error = fmt.Errorf("%v: %s", decoder.arrayType, iter.Error.Error())
+        }
+}
+
+func (decoder *arrayDecoder) doDecode(ptr unsafe.Pointer, iter *Iterator) {
+        c := iter.nextToken()
+        arrayType := decoder.arrayType
+        if c == 'n' {
+                iter.skipThreeBytes('u', 'l', 'l')
+                return
+        }
+        if c != '[' {
+                iter.ReportError("decode array", "expect [ or n, but found "+string([]byte{c}))
+                return
+        }
+        c = iter.nextToken()
+        if c == ']' {
+                return
+        }
+        iter.unreadByte()
+        elemPtr := arrayType.UnsafeGetIndex(ptr, 0)
+        decoder.elemDecoder.Decode(elemPtr, iter)
+        length := 1
+        for c = iter.nextToken(); c == ','; c = iter.nextToken() {
+                if length >= arrayType.Len() {
+                        iter.Skip()
+                        continue
+                }
+                idx := length
+                length += 1
+                elemPtr = arrayType.UnsafeGetIndex(ptr, idx)
+                decoder.elemDecoder.Decode(elemPtr, iter)
+        }
+        if c != ']' {
+                iter.ReportError("decode array", "expect ], but found "+string([]byte{c}))
+                return
+        }
+}
diff --git a/vendor/github.com/json-iterator/go/reflect_dynamic.go b/vendor/github.com/json-iterator/go/reflect_dynamic.go
new file mode 100644
index 0000000..8b6bc8b
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/reflect_dynamic.go
@@ -0,0 +1,70 @@
+package jsoniter
+
+import (
+        "github.com/modern-go/reflect2"
+        "reflect"
+        "unsafe"
+)
+
+type dynamicEncoder struct {
+        valType reflect2.Type
+}
+
+func (encoder *dynamicEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        obj := encoder.valType.UnsafeIndirect(ptr)
+        stream.WriteVal(obj)
+}
+
+func (encoder *dynamicEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return encoder.valType.UnsafeIndirect(ptr) == nil
+}
+
+type efaceDecoder struct {
+}
+
+func (decoder *efaceDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        pObj := (*interface{})(ptr)
+        obj := *pObj
+        if obj == nil {
+                *pObj = iter.Read()
+                return
+        }
+        typ := reflect2.TypeOf(obj)
+        if typ.Kind() != reflect.Ptr {
+                *pObj = iter.Read()
+                return
+        }
+        ptrType := typ.(*reflect2.UnsafePtrType)
+        ptrElemType := ptrType.Elem()
+        if iter.WhatIsNext() == NilValue {
+                if ptrElemType.Kind() != reflect.Ptr {
+                        iter.skipFourBytes('n', 'u', 'l', 'l')
+                        *pObj = nil
+                        return
+                }
+        }
+        if reflect2.IsNil(obj) {
+                obj := ptrElemType.New()
+                iter.ReadVal(obj)
+                *pObj = obj
+                return
+        }
+        iter.ReadVal(obj)
+}
+
+type ifaceDecoder struct {
+        valType *reflect2.UnsafeIFaceType
+}
+
+func (decoder *ifaceDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if iter.ReadNil() {
+                decoder.valType.UnsafeSet(ptr, decoder.valType.UnsafeNew())
+                return
+        }
+        obj := decoder.valType.UnsafeIndirect(ptr)
+        if reflect2.IsNil(obj) {
+                iter.ReportError("decode non empty interface", "can not unmarshal into nil")
+                return
+        }
+        iter.ReadVal(obj)
+}
diff --git a/vendor/github.com/json-iterator/go/reflect_extension.go b/vendor/github.com/json-iterator/go/reflect_extension.go
new file mode 100644
index 0000000..74a97bf
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/reflect_extension.go
@@ -0,0 +1,483 @@
+package jsoniter
+
+import (
+        "fmt"
+        "github.com/modern-go/reflect2"
+        "reflect"
+        "sort"
+        "strings"
+        "unicode"
+        "unsafe"
+)
+
+var typeDecoders = map[string]ValDecoder{}
+var fieldDecoders = map[string]ValDecoder{}
+var typeEncoders = map[string]ValEncoder{}
+var fieldEncoders = map[string]ValEncoder{}
+var extensions = []Extension{}
+
+// StructDescriptor describe how should we encode/decode the struct
+type StructDescriptor struct {
+        Type   reflect2.Type
+        Fields []*Binding
+}
+
+// GetField get one field from the descriptor by its name.
+// Can not use map here to keep field orders.
+func (structDescriptor *StructDescriptor) GetField(fieldName string) *Binding {
+        for _, binding := range structDescriptor.Fields {
+                if binding.Field.Name() == fieldName {
+                        return binding
+                }
+        }
+        return nil
+}
+
+// Binding describe how should we encode/decode the struct field
+type Binding struct {
+        levels    []int
+        Field     reflect2.StructField
+        FromNames []string
+        ToNames   []string
+        Encoder   ValEncoder
+        Decoder   ValDecoder
+}
+
+// Extension the one for all SPI. Customize encoding/decoding by specifying alternate encoder/decoder.
+// Can also rename fields by UpdateStructDescriptor.
+type Extension interface {
+        UpdateStructDescriptor(structDescriptor *StructDescriptor)
+        CreateMapKeyDecoder(typ reflect2.Type) ValDecoder
+        CreateMapKeyEncoder(typ reflect2.Type) ValEncoder
+        CreateDecoder(typ reflect2.Type) ValDecoder
+        CreateEncoder(typ reflect2.Type) ValEncoder
+        DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder
+        DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder
+}
+
+// DummyExtension embed this type get dummy implementation for all methods of Extension
+type DummyExtension struct {
+}
+
+// UpdateStructDescriptor No-op
+func (extension *DummyExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor) {
+}
+
+// CreateMapKeyDecoder No-op
+func (extension *DummyExtension) CreateMapKeyDecoder(typ reflect2.Type) ValDecoder {
+        return nil
+}
+
+// CreateMapKeyEncoder No-op
+func (extension *DummyExtension) CreateMapKeyEncoder(typ reflect2.Type) ValEncoder {
+        return nil
+}
+
+// CreateDecoder No-op
+func (extension *DummyExtension) CreateDecoder(typ reflect2.Type) ValDecoder {
+        return nil
+}
+
+// CreateEncoder No-op
+func (extension *DummyExtension) CreateEncoder(typ reflect2.Type) ValEncoder {
+        return nil
+}
+
+// DecorateDecoder No-op
+func (extension *DummyExtension) DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder {
+        return decoder
+}
+
+// DecorateEncoder No-op
+func (extension *DummyExtension) DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder {
+        return encoder
+}
+
+type EncoderExtension map[reflect2.Type]ValEncoder
+
+// UpdateStructDescriptor No-op
+func (extension EncoderExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor) {
+}
+
+// CreateDecoder No-op
+func (extension EncoderExtension) CreateDecoder(typ reflect2.Type) ValDecoder {
+        return nil
+}
+
+// CreateEncoder get encoder from map
+func (extension EncoderExtension) CreateEncoder(typ reflect2.Type) ValEncoder {
+        return extension[typ]
+}
+
+// CreateMapKeyDecoder No-op
+func (extension EncoderExtension) CreateMapKeyDecoder(typ reflect2.Type) ValDecoder {
+        return nil
+}
+
+// CreateMapKeyEncoder No-op
+func (extension EncoderExtension) CreateMapKeyEncoder(typ reflect2.Type) ValEncoder {
+        return nil
+}
+
+// DecorateDecoder No-op
+func (extension EncoderExtension) DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder {
+        return decoder
+}
+
+// DecorateEncoder No-op
+func (extension EncoderExtension) DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder {
+        return encoder
+}
+
+type DecoderExtension map[reflect2.Type]ValDecoder
+
+// UpdateStructDescriptor No-op
+func (extension DecoderExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor) {
+}
+
+// CreateMapKeyDecoder No-op
+func (extension DecoderExtension) CreateMapKeyDecoder(typ reflect2.Type) ValDecoder {
+        return nil
+}
+
+// CreateMapKeyEncoder No-op
+func (extension DecoderExtension) CreateMapKeyEncoder(typ reflect2.Type) ValEncoder {
+        return nil
+}
+
+// CreateDecoder get decoder from map
+func (extension DecoderExtension) CreateDecoder(typ reflect2.Type) ValDecoder {
+        return extension[typ]
+}
+
+// CreateEncoder No-op
+func (extension DecoderExtension) CreateEncoder(typ reflect2.Type) ValEncoder {
+        return nil
+}
+
+// DecorateDecoder No-op
+func (extension DecoderExtension) DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder {
+        return decoder
+}
+
+// DecorateEncoder No-op
+func (extension DecoderExtension) DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder {
+        return encoder
+}
+
+type funcDecoder struct {
+        fun DecoderFunc
+}
+
+func (decoder *funcDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        decoder.fun(ptr, iter)
+}
+
+type funcEncoder struct {
+        fun         EncoderFunc
+        isEmptyFunc func(ptr unsafe.Pointer) bool
+}
+
+func (encoder *funcEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        encoder.fun(ptr, stream)
+}
+
+func (encoder *funcEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        if encoder.isEmptyFunc == nil {
+                return false
+        }
+        return encoder.isEmptyFunc(ptr)
+}
+
+// DecoderFunc the function form of TypeDecoder
+type DecoderFunc func(ptr unsafe.Pointer, iter *Iterator)
+
+// EncoderFunc the function form of TypeEncoder
+type EncoderFunc func(ptr unsafe.Pointer, stream *Stream)
+
+// RegisterTypeDecoderFunc register TypeDecoder for a type with function
+func RegisterTypeDecoderFunc(typ string, fun DecoderFunc) {
+        typeDecoders[typ] = &funcDecoder{fun}
+}
+
+// RegisterTypeDecoder register TypeDecoder for a typ
+func RegisterTypeDecoder(typ string, decoder ValDecoder) {
+        typeDecoders[typ] = decoder
+}
+
+// RegisterFieldDecoderFunc register TypeDecoder for a struct field with function
+func RegisterFieldDecoderFunc(typ string, field string, fun DecoderFunc) {
+        RegisterFieldDecoder(typ, field, &funcDecoder{fun})
+}
+
+// RegisterFieldDecoder register TypeDecoder for a struct field
+func RegisterFieldDecoder(typ string, field string, decoder ValDecoder) {
+        fieldDecoders[fmt.Sprintf("%s/%s", typ, field)] = decoder
+}
+
+// RegisterTypeEncoderFunc register TypeEncoder for a type with encode/isEmpty function
+func RegisterTypeEncoderFunc(typ string, fun EncoderFunc, isEmptyFunc func(unsafe.Pointer) bool) {
+        typeEncoders[typ] = &funcEncoder{fun, isEmptyFunc}
+}
+
+// RegisterTypeEncoder register TypeEncoder for a type
+func RegisterTypeEncoder(typ string, encoder ValEncoder) {
+        typeEncoders[typ] = encoder
+}
+
+// RegisterFieldEncoderFunc register TypeEncoder for a struct field with encode/isEmpty function
+func RegisterFieldEncoderFunc(typ string, field string, fun EncoderFunc, isEmptyFunc func(unsafe.Pointer) bool) {
+        RegisterFieldEncoder(typ, field, &funcEncoder{fun, isEmptyFunc})
+}
+
+// RegisterFieldEncoder register TypeEncoder for a struct field
+func RegisterFieldEncoder(typ string, field string, encoder ValEncoder) {
+        fieldEncoders[fmt.Sprintf("%s/%s", typ, field)] = encoder
+}
+
+// RegisterExtension register extension
+func RegisterExtension(extension Extension) {
+        extensions = append(extensions, extension)
+}
+
+func getTypeDecoderFromExtension(ctx *ctx, typ reflect2.Type) ValDecoder {
+        decoder := _getTypeDecoderFromExtension(ctx, typ)
+        if decoder != nil {
+                for _, extension := range extensions {
+                        decoder = extension.DecorateDecoder(typ, decoder)
+                }
+                decoder = ctx.decoderExtension.DecorateDecoder(typ, decoder)
+                for _, extension := range ctx.extraExtensions {
+                        decoder = extension.DecorateDecoder(typ, decoder)
+                }
+        }
+        return decoder
+}
+func _getTypeDecoderFromExtension(ctx *ctx, typ reflect2.Type) ValDecoder {
+        for _, extension := range extensions {
+                decoder := extension.CreateDecoder(typ)
+                if decoder != nil {
+                        return decoder
+                }
+        }
+        decoder := ctx.decoderExtension.CreateDecoder(typ)
+        if decoder != nil {
+                return decoder
+        }
+        for _, extension := range ctx.extraExtensions {
+                decoder := extension.CreateDecoder(typ)
+                if decoder != nil {
+                        return decoder
+                }
+        }
+        typeName := typ.String()
+        decoder = typeDecoders[typeName]
+        if decoder != nil {
+                return decoder
+        }
+        if typ.Kind() == reflect.Ptr {
+                ptrType := typ.(*reflect2.UnsafePtrType)
+                decoder := typeDecoders[ptrType.Elem().String()]
+                if decoder != nil {
+                        return &OptionalDecoder{ptrType.Elem(), decoder}
+                }
+        }
+        return nil
+}
+
+func getTypeEncoderFromExtension(ctx *ctx, typ reflect2.Type) ValEncoder {
+        encoder := _getTypeEncoderFromExtension(ctx, typ)
+        if encoder != nil {
+                for _, extension := range extensions {
+                        encoder = extension.DecorateEncoder(typ, encoder)
+                }
+                encoder = ctx.encoderExtension.DecorateEncoder(typ, encoder)
+                for _, extension := range ctx.extraExtensions {
+                        encoder = extension.DecorateEncoder(typ, encoder)
+                }
+        }
+        return encoder
+}
+
+func _getTypeEncoderFromExtension(ctx *ctx, typ reflect2.Type) ValEncoder {
+        for _, extension := range extensions {
+                encoder := extension.CreateEncoder(typ)
+                if encoder != nil {
+                        return encoder
+                }
+        }
+        encoder := ctx.encoderExtension.CreateEncoder(typ)
+        if encoder != nil {
+                return encoder
+        }
+        for _, extension := range ctx.extraExtensions {
+                encoder := extension.CreateEncoder(typ)
+                if encoder != nil {
+                        return encoder
+                }
+        }
+        typeName := typ.String()
+        encoder = typeEncoders[typeName]
+        if encoder != nil {
+                return encoder
+        }
+        if typ.Kind() == reflect.Ptr {
+                typePtr := typ.(*reflect2.UnsafePtrType)
+                encoder := typeEncoders[typePtr.Elem().String()]
+                if encoder != nil {
+                        return &OptionalEncoder{encoder}
+                }
+        }
+        return nil
+}
+
+func describeStruct(ctx *ctx, typ reflect2.Type) *StructDescriptor {
+        structType := typ.(*reflect2.UnsafeStructType)
+        embeddedBindings := []*Binding{}
+        bindings := []*Binding{}
+        for i := 0; i < structType.NumField(); i++ {
+                field := structType.Field(i)
+                tag, hastag := field.Tag().Lookup(ctx.getTagKey())
+                if ctx.onlyTaggedField && !hastag && !field.Anonymous() {
+                        continue
+                }
+                if tag == "-" || field.Name() == "_" {
+                        continue
+                }
+                tagParts := strings.Split(tag, ",")
+                if field.Anonymous() && (tag == "" || tagParts[0] == "") {
+                        if field.Type().Kind() == reflect.Struct {
+                                structDescriptor := describeStruct(ctx, field.Type())
+                                for _, binding := range structDescriptor.Fields {
+                                        binding.levels = append([]int{i}, binding.levels...)
+                                        omitempty := binding.Encoder.(*structFieldEncoder).omitempty
+                                        binding.Encoder = &structFieldEncoder{field, binding.Encoder, omitempty}
+                                        binding.Decoder = &structFieldDecoder{field, binding.Decoder}
+                                        embeddedBindings = append(embeddedBindings, binding)
+                                }
+                                continue
+                        } else if field.Type().Kind() == reflect.Ptr {
+                                ptrType := field.Type().(*reflect2.UnsafePtrType)
+                                if ptrType.Elem().Kind() == reflect.Struct {
+                                        structDescriptor := describeStruct(ctx, ptrType.Elem())
+                                        for _, binding := range structDescriptor.Fields {
+                                                binding.levels = append([]int{i}, binding.levels...)
+                                                omitempty := binding.Encoder.(*structFieldEncoder).omitempty
+                                                binding.Encoder = &dereferenceEncoder{binding.Encoder}
+                                                binding.Encoder = &structFieldEncoder{field, binding.Encoder, omitempty}
+                                                binding.Decoder = &dereferenceDecoder{ptrType.Elem(), binding.Decoder}
+                                                binding.Decoder = &structFieldDecoder{field, binding.Decoder}
+                                                embeddedBindings = append(embeddedBindings, binding)
+                                        }
+                                        continue
+                                }
+                        }
+                }
+                fieldNames := calcFieldNames(field.Name(), tagParts[0], tag)
+                fieldCacheKey := fmt.Sprintf("%s/%s", typ.String(), field.Name())
+                decoder := fieldDecoders[fieldCacheKey]
+                if decoder == nil {
+                        decoder = decoderOfType(ctx.append(field.Name()), field.Type())
+                }
+                encoder := fieldEncoders[fieldCacheKey]
+                if encoder == nil {
+                        encoder = encoderOfType(ctx.append(field.Name()), field.Type())
+                }
+                binding := &Binding{
+                        Field:     field,
+                        FromNames: fieldNames,
+                        ToNames:   fieldNames,
+                        Decoder:   decoder,
+                        Encoder:   encoder,
+                }
+                binding.levels = []int{i}
+                bindings = append(bindings, binding)
+        }
+        return createStructDescriptor(ctx, typ, bindings, embeddedBindings)
+}
+func createStructDescriptor(ctx *ctx, typ reflect2.Type, bindings []*Binding, embeddedBindings []*Binding) *StructDescriptor {
+        structDescriptor := &StructDescriptor{
+                Type:   typ,
+                Fields: bindings,
+        }
+        for _, extension := range extensions {
+                extension.UpdateStructDescriptor(structDescriptor)
+        }
+        ctx.encoderExtension.UpdateStructDescriptor(structDescriptor)
+        ctx.decoderExtension.UpdateStructDescriptor(structDescriptor)
+        for _, extension := range ctx.extraExtensions {
+                extension.UpdateStructDescriptor(structDescriptor)
+        }
+        processTags(structDescriptor, ctx.frozenConfig)
+        // merge normal & embedded bindings & sort with original order
+        allBindings := sortableBindings(append(embeddedBindings, structDescriptor.Fields...))
+        sort.Sort(allBindings)
+        structDescriptor.Fields = allBindings
+        return structDescriptor
+}
+
+type sortableBindings []*Binding
+
+func (bindings sortableBindings) Len() int {
+        return len(bindings)
+}
+
+func (bindings sortableBindings) Less(i, j int) bool {
+        left := bindings[i].levels
+        right := bindings[j].levels
+        k := 0
+        for {
+                if left[k] < right[k] {
+                        return true
+                } else if left[k] > right[k] {
+                        return false
+                }
+                k++
+        }
+}
+
+func (bindings sortableBindings) Swap(i, j int) {
+        bindings[i], bindings[j] = bindings[j], bindings[i]
+}
+
+func processTags(structDescriptor *StructDescriptor, cfg *frozenConfig) {
+        for _, binding := range structDescriptor.Fields {
+                shouldOmitEmpty := false
+                tagParts := strings.Split(binding.Field.Tag().Get(cfg.getTagKey()), ",")
+                for _, tagPart := range tagParts[1:] {
+                        if tagPart == "omitempty" {
+                                shouldOmitEmpty = true
+                        } else if tagPart == "string" {
+                                if binding.Field.Type().Kind() == reflect.String {
+                                        binding.Decoder = &stringModeStringDecoder{binding.Decoder, cfg}
+                                        binding.Encoder = &stringModeStringEncoder{binding.Encoder, cfg}
+                                } else {
+                                        binding.Decoder = &stringModeNumberDecoder{binding.Decoder}
+                                        binding.Encoder = &stringModeNumberEncoder{binding.Encoder}
+                                }
+                        }
+                }
+                binding.Decoder = &structFieldDecoder{binding.Field, binding.Decoder}
+                binding.Encoder = &structFieldEncoder{binding.Field, binding.Encoder, shouldOmitEmpty}
+        }
+}
+
+func calcFieldNames(originalFieldName string, tagProvidedFieldName string, wholeTag string) []string {
+        // ignore?
+        if wholeTag == "-" {
+                return []string{}
+        }
+        // rename?
+        var fieldNames []string
+        if tagProvidedFieldName == "" {
+                fieldNames = []string{originalFieldName}
+        } else {
+                fieldNames = []string{tagProvidedFieldName}
+        }
+        // private?
+        isNotExported := unicode.IsLower(rune(originalFieldName[0])) || originalFieldName[0] == '_'
+        if isNotExported {
+                fieldNames = []string{}
+        }
+        return fieldNames
+}
diff --git a/vendor/github.com/json-iterator/go/reflect_json_number.go b/vendor/github.com/json-iterator/go/reflect_json_number.go
new file mode 100644
index 0000000..98d45c1
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/reflect_json_number.go
@@ -0,0 +1,112 @@
+package jsoniter
+
+import (
+        "encoding/json"
+        "github.com/modern-go/reflect2"
+        "strconv"
+        "unsafe"
+)
+
+type Number string
+
+// String returns the literal text of the number.
+func (n Number) String() string { return string(n) }
+
+// Float64 returns the number as a float64.
+func (n Number) Float64() (float64, error) {
+        return strconv.ParseFloat(string(n), 64)
+}
+
+// Int64 returns the number as an int64.
+func (n Number) Int64() (int64, error) {
+        return strconv.ParseInt(string(n), 10, 64)
+}
+
+func CastJsonNumber(val interface{}) (string, bool) {
+        switch typedVal := val.(type) {
+        case json.Number:
+                return string(typedVal), true
+        case Number:
+                return string(typedVal), true
+        }
+        return "", false
+}
+
+var jsonNumberType = reflect2.TypeOfPtr((*json.Number)(nil)).Elem()
+var jsoniterNumberType = reflect2.TypeOfPtr((*Number)(nil)).Elem()
+
+func createDecoderOfJsonNumber(ctx *ctx, typ reflect2.Type) ValDecoder {
+        if typ.AssignableTo(jsonNumberType) {
+                return &jsonNumberCodec{}
+        }
+        if typ.AssignableTo(jsoniterNumberType) {
+                return &jsoniterNumberCodec{}
+        }
+        return nil
+}
+
+func createEncoderOfJsonNumber(ctx *ctx, typ reflect2.Type) ValEncoder {
+        if typ.AssignableTo(jsonNumberType) {
+                return &jsonNumberCodec{}
+        }
+        if typ.AssignableTo(jsoniterNumberType) {
+                return &jsoniterNumberCodec{}
+        }
+        return nil
+}
+
+type jsonNumberCodec struct {
+}
+
+func (codec *jsonNumberCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        switch iter.WhatIsNext() {
+        case StringValue:
+                *((*json.Number)(ptr)) = json.Number(iter.ReadString())
+        case NilValue:
+                iter.skipFourBytes('n', 'u', 'l', 'l')
+                *((*json.Number)(ptr)) = ""
+        default:
+                *((*json.Number)(ptr)) = json.Number([]byte(iter.readNumberAsString()))
+        }
+}
+
+func (codec *jsonNumberCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        number := *((*json.Number)(ptr))
+        if len(number) == 0 {
+                stream.writeByte('0')
+        } else {
+                stream.WriteRaw(string(number))
+        }
+}
+
+func (codec *jsonNumberCodec) IsEmpty(ptr unsafe.Pointer) bool {
+        return len(*((*json.Number)(ptr))) == 0
+}
+
+type jsoniterNumberCodec struct {
+}
+
+func (codec *jsoniterNumberCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        switch iter.WhatIsNext() {
+        case StringValue:
+                *((*Number)(ptr)) = Number(iter.ReadString())
+        case NilValue:
+                iter.skipFourBytes('n', 'u', 'l', 'l')
+                *((*Number)(ptr)) = ""
+        default:
+                *((*Number)(ptr)) = Number([]byte(iter.readNumberAsString()))
+        }
+}
+
+func (codec *jsoniterNumberCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        number := *((*Number)(ptr))
+        if len(number) == 0 {
+                stream.writeByte('0')
+        } else {
+                stream.WriteRaw(string(number))
+        }
+}
+
+func (codec *jsoniterNumberCodec) IsEmpty(ptr unsafe.Pointer) bool {
+        return len(*((*Number)(ptr))) == 0
+}
diff --git a/vendor/github.com/json-iterator/go/reflect_json_raw_message.go b/vendor/github.com/json-iterator/go/reflect_json_raw_message.go
new file mode 100644
index 0000000..eba434f
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/reflect_json_raw_message.go
@@ -0,0 +1,76 @@
+package jsoniter
+
+import (
+        "encoding/json"
+        "github.com/modern-go/reflect2"
+        "unsafe"
+)
+
+var jsonRawMessageType = reflect2.TypeOfPtr((*json.RawMessage)(nil)).Elem()
+var jsoniterRawMessageType = reflect2.TypeOfPtr((*RawMessage)(nil)).Elem()
+
+func createEncoderOfJsonRawMessage(ctx *ctx, typ reflect2.Type) ValEncoder {
+        if typ == jsonRawMessageType {
+                return &jsonRawMessageCodec{}
+        }
+        if typ == jsoniterRawMessageType {
+                return &jsoniterRawMessageCodec{}
+        }
+        return nil
+}
+
+func createDecoderOfJsonRawMessage(ctx *ctx, typ reflect2.Type) ValDecoder {
+        if typ == jsonRawMessageType {
+                return &jsonRawMessageCodec{}
+        }
+        if typ == jsoniterRawMessageType {
+                return &jsoniterRawMessageCodec{}
+        }
+        return nil
+}
+
+type jsonRawMessageCodec struct {
+}
+
+func (codec *jsonRawMessageCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if iter.ReadNil() {
+                *((*json.RawMessage)(ptr)) = nil
+        } else {
+                *((*json.RawMessage)(ptr)) = iter.SkipAndReturnBytes()
+        }
+}
+
+func (codec *jsonRawMessageCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        if *((*json.RawMessage)(ptr)) == nil {
+                stream.WriteNil()
+        } else {
+                stream.WriteRaw(string(*((*json.RawMessage)(ptr))))
+        }
+}
+
+func (codec *jsonRawMessageCodec) IsEmpty(ptr unsafe.Pointer) bool {
+        return len(*((*json.RawMessage)(ptr))) == 0
+}
+
+type jsoniterRawMessageCodec struct {
+}
+
+func (codec *jsoniterRawMessageCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if iter.ReadNil() {
+                *((*RawMessage)(ptr)) = nil
+        } else {
+                *((*RawMessage)(ptr)) = iter.SkipAndReturnBytes()
+        }
+}
+
+func (codec *jsoniterRawMessageCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        if *((*RawMessage)(ptr)) == nil {
+                stream.WriteNil()
+        } else {
+                stream.WriteRaw(string(*((*RawMessage)(ptr))))
+        }
+}
+
+func (codec *jsoniterRawMessageCodec) IsEmpty(ptr unsafe.Pointer) bool {
+        return len(*((*RawMessage)(ptr))) == 0
+}
diff --git a/vendor/github.com/json-iterator/go/reflect_map.go b/vendor/github.com/json-iterator/go/reflect_map.go
new file mode 100644
index 0000000..5829671
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/reflect_map.go
@@ -0,0 +1,346 @@
+package jsoniter
+
+import (
+        "fmt"
+        "github.com/modern-go/reflect2"
+        "io"
+        "reflect"
+        "sort"
+        "unsafe"
+)
+
+func decoderOfMap(ctx *ctx, typ reflect2.Type) ValDecoder {
+        mapType := typ.(*reflect2.UnsafeMapType)
+        keyDecoder := decoderOfMapKey(ctx.append("[mapKey]"), mapType.Key())
+        elemDecoder := decoderOfType(ctx.append("[mapElem]"), mapType.Elem())
+        return &mapDecoder{
+                mapType:     mapType,
+                keyType:     mapType.Key(),
+                elemType:    mapType.Elem(),
+                keyDecoder:  keyDecoder,
+                elemDecoder: elemDecoder,
+        }
+}
+
+func encoderOfMap(ctx *ctx, typ reflect2.Type) ValEncoder {
+        mapType := typ.(*reflect2.UnsafeMapType)
+        if ctx.sortMapKeys {
+                return &sortKeysMapEncoder{
+                        mapType:     mapType,
+                        keyEncoder:  encoderOfMapKey(ctx.append("[mapKey]"), mapType.Key()),
+                        elemEncoder: encoderOfType(ctx.append("[mapElem]"), mapType.Elem()),
+                }
+        }
+        return &mapEncoder{
+                mapType:     mapType,
+                keyEncoder:  encoderOfMapKey(ctx.append("[mapKey]"), mapType.Key()),
+                elemEncoder: encoderOfType(ctx.append("[mapElem]"), mapType.Elem()),
+        }
+}
+
+func decoderOfMapKey(ctx *ctx, typ reflect2.Type) ValDecoder {
+        decoder := ctx.decoderExtension.CreateMapKeyDecoder(typ)
+        if decoder != nil {
+                return decoder
+        }
+        for _, extension := range ctx.extraExtensions {
+                decoder := extension.CreateMapKeyDecoder(typ)
+                if decoder != nil {
+                        return decoder
+                }
+        }
+
+        ptrType := reflect2.PtrTo(typ)
+        if ptrType.Implements(unmarshalerType) {
+                return &referenceDecoder{
+                        &unmarshalerDecoder{
+                                valType: ptrType,
+                        },
+                }
+        }
+        if typ.Implements(unmarshalerType) {
+                return &unmarshalerDecoder{
+                        valType: typ,
+                }
+        }
+        if ptrType.Implements(textUnmarshalerType) {
+                return &referenceDecoder{
+                        &textUnmarshalerDecoder{
+                                valType: ptrType,
+                        },
+                }
+        }
+        if typ.Implements(textUnmarshalerType) {
+                return &textUnmarshalerDecoder{
+                        valType: typ,
+                }
+        }
+
+        switch typ.Kind() {
+        case reflect.String:
+                return decoderOfType(ctx, reflect2.DefaultTypeOfKind(reflect.String))
+        case reflect.Bool,
+                reflect.Uint8, reflect.Int8,
+                reflect.Uint16, reflect.Int16,
+                reflect.Uint32, reflect.Int32,
+                reflect.Uint64, reflect.Int64,
+                reflect.Uint, reflect.Int,
+                reflect.Float32, reflect.Float64,
+                reflect.Uintptr:
+                typ = reflect2.DefaultTypeOfKind(typ.Kind())
+                return &numericMapKeyDecoder{decoderOfType(ctx, typ)}
+        default:
+                return &lazyErrorDecoder{err: fmt.Errorf("unsupported map key type: %v", typ)}
+        }
+}
+
+func encoderOfMapKey(ctx *ctx, typ reflect2.Type) ValEncoder {
+        encoder := ctx.encoderExtension.CreateMapKeyEncoder(typ)
+        if encoder != nil {
+                return encoder
+        }
+        for _, extension := range ctx.extraExtensions {
+                encoder := extension.CreateMapKeyEncoder(typ)
+                if encoder != nil {
+                        return encoder
+                }
+        }
+
+        if typ == textMarshalerType {
+                return &directTextMarshalerEncoder{
+                        stringEncoder: ctx.EncoderOf(reflect2.TypeOf("")),
+                }
+        }
+        if typ.Implements(textMarshalerType) {
+                return &textMarshalerEncoder{
+                        valType:       typ,
+                        stringEncoder: ctx.EncoderOf(reflect2.TypeOf("")),
+                }
+        }
+
+        switch typ.Kind() {
+        case reflect.String:
+                return encoderOfType(ctx, reflect2.DefaultTypeOfKind(reflect.String))
+        case reflect.Bool,
+                reflect.Uint8, reflect.Int8,
+                reflect.Uint16, reflect.Int16,
+                reflect.Uint32, reflect.Int32,
+                reflect.Uint64, reflect.Int64,
+                reflect.Uint, reflect.Int,
+                reflect.Float32, reflect.Float64,
+                reflect.Uintptr:
+                typ = reflect2.DefaultTypeOfKind(typ.Kind())
+                return &numericMapKeyEncoder{encoderOfType(ctx, typ)}
+        default:
+                if typ.Kind() == reflect.Interface {
+                        return &dynamicMapKeyEncoder{ctx, typ}
+                }
+                return &lazyErrorEncoder{err: fmt.Errorf("unsupported map key type: %v", typ)}
+        }
+}
+
+type mapDecoder struct {
+        mapType     *reflect2.UnsafeMapType
+        keyType     reflect2.Type
+        elemType    reflect2.Type
+        keyDecoder  ValDecoder
+        elemDecoder ValDecoder
+}
+
+func (decoder *mapDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        mapType := decoder.mapType
+        c := iter.nextToken()
+        if c == 'n' {
+                iter.skipThreeBytes('u', 'l', 'l')
+                *(*unsafe.Pointer)(ptr) = nil
+                mapType.UnsafeSet(ptr, mapType.UnsafeNew())
+                return
+        }
+        if mapType.UnsafeIsNil(ptr) {
+                mapType.UnsafeSet(ptr, mapType.UnsafeMakeMap(0))
+        }
+        if c != '{' {
+                iter.ReportError("ReadMapCB", `expect { or n, but found `+string([]byte{c}))
+                return
+        }
+        c = iter.nextToken()
+        if c == '}' {
+                return
+        }
+        iter.unreadByte()
+        key := decoder.keyType.UnsafeNew()
+        decoder.keyDecoder.Decode(key, iter)
+        c = iter.nextToken()
+        if c != ':' {
+                iter.ReportError("ReadMapCB", "expect : after object field, but found "+string([]byte{c}))
+                return
+        }
+        elem := decoder.elemType.UnsafeNew()
+        decoder.elemDecoder.Decode(elem, iter)
+        decoder.mapType.UnsafeSetIndex(ptr, key, elem)
+        for c = iter.nextToken(); c == ','; c = iter.nextToken() {
+                key := decoder.keyType.UnsafeNew()
+                decoder.keyDecoder.Decode(key, iter)
+                c = iter.nextToken()
+                if c != ':' {
+                        iter.ReportError("ReadMapCB", "expect : after object field, but found "+string([]byte{c}))
+                        return
+                }
+                elem := decoder.elemType.UnsafeNew()
+                decoder.elemDecoder.Decode(elem, iter)
+                decoder.mapType.UnsafeSetIndex(ptr, key, elem)
+        }
+        if c != '}' {
+                iter.ReportError("ReadMapCB", `expect }, but found `+string([]byte{c}))
+        }
+}
+
+type numericMapKeyDecoder struct {
+        decoder ValDecoder
+}
+
+func (decoder *numericMapKeyDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        c := iter.nextToken()
+        if c != '"' {
+                iter.ReportError("ReadMapCB", `expect ", but found `+string([]byte{c}))
+                return
+        }
+        decoder.decoder.Decode(ptr, iter)
+        c = iter.nextToken()
+        if c != '"' {
+                iter.ReportError("ReadMapCB", `expect ", but found `+string([]byte{c}))
+                return
+        }
+}
+
+type numericMapKeyEncoder struct {
+        encoder ValEncoder
+}
+
+func (encoder *numericMapKeyEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.writeByte('"')
+        encoder.encoder.Encode(ptr, stream)
+        stream.writeByte('"')
+}
+
+func (encoder *numericMapKeyEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return false
+}
+
+type dynamicMapKeyEncoder struct {
+        ctx     *ctx
+        valType reflect2.Type
+}
+
+func (encoder *dynamicMapKeyEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        obj := encoder.valType.UnsafeIndirect(ptr)
+        encoderOfMapKey(encoder.ctx, reflect2.TypeOf(obj)).Encode(reflect2.PtrOf(obj), stream)
+}
+
+func (encoder *dynamicMapKeyEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        obj := encoder.valType.UnsafeIndirect(ptr)
+        return encoderOfMapKey(encoder.ctx, reflect2.TypeOf(obj)).IsEmpty(reflect2.PtrOf(obj))
+}
+
+type mapEncoder struct {
+        mapType     *reflect2.UnsafeMapType
+        keyEncoder  ValEncoder
+        elemEncoder ValEncoder
+}
+
+func (encoder *mapEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        if *(*unsafe.Pointer)(ptr) == nil {
+                stream.WriteNil()
+                return
+        }
+        stream.WriteObjectStart()
+        iter := encoder.mapType.UnsafeIterate(ptr)
+        for i := 0; iter.HasNext(); i++ {
+                if i != 0 {
+                        stream.WriteMore()
+                }
+                key, elem := iter.UnsafeNext()
+                encoder.keyEncoder.Encode(key, stream)
+                if stream.indention > 0 {
+                        stream.writeTwoBytes(byte(':'), byte(' '))
+                } else {
+                        stream.writeByte(':')
+                }
+                encoder.elemEncoder.Encode(elem, stream)
+        }
+        stream.WriteObjectEnd()
+}
+
+func (encoder *mapEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        iter := encoder.mapType.UnsafeIterate(ptr)
+        return !iter.HasNext()
+}
+
+type sortKeysMapEncoder struct {
+        mapType     *reflect2.UnsafeMapType
+        keyEncoder  ValEncoder
+        elemEncoder ValEncoder
+}
+
+func (encoder *sortKeysMapEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        if *(*unsafe.Pointer)(ptr) == nil {
+                stream.WriteNil()
+                return
+        }
+        stream.WriteObjectStart()
+        mapIter := encoder.mapType.UnsafeIterate(ptr)
+        subStream := stream.cfg.BorrowStream(nil)
+        subStream.Attachment = stream.Attachment
+        subIter := stream.cfg.BorrowIterator(nil)
+        keyValues := encodedKeyValues{}
+        for mapIter.HasNext() {
+                key, elem := mapIter.UnsafeNext()
+                subStreamIndex := subStream.Buffered()
+                encoder.keyEncoder.Encode(key, subStream)
+                if subStream.Error != nil && subStream.Error != io.EOF && stream.Error == nil {
+                        stream.Error = subStream.Error
+                }
+                encodedKey := subStream.Buffer()[subStreamIndex:]
+                subIter.ResetBytes(encodedKey)
+                decodedKey := subIter.ReadString()
+                if stream.indention > 0 {
+                        subStream.writeTwoBytes(byte(':'), byte(' '))
+                } else {
+                        subStream.writeByte(':')
+                }
+                encoder.elemEncoder.Encode(elem, subStream)
+                keyValues = append(keyValues, encodedKV{
+                        key:      decodedKey,
+                        keyValue: subStream.Buffer()[subStreamIndex:],
+                })
+        }
+        sort.Sort(keyValues)
+        for i, keyValue := range keyValues {
+                if i != 0 {
+                        stream.WriteMore()
+                }
+                stream.Write(keyValue.keyValue)
+        }
+        if subStream.Error != nil && stream.Error == nil {
+                stream.Error = subStream.Error
+        }
+        stream.WriteObjectEnd()
+        stream.cfg.ReturnStream(subStream)
+        stream.cfg.ReturnIterator(subIter)
+}
+
+func (encoder *sortKeysMapEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        iter := encoder.mapType.UnsafeIterate(ptr)
+        return !iter.HasNext()
+}
+
+type encodedKeyValues []encodedKV
+
+type encodedKV struct {
+        key      string
+        keyValue []byte
+}
+
+func (sv encodedKeyValues) Len() int           { return len(sv) }
+func (sv encodedKeyValues) Swap(i, j int)      { sv[i], sv[j] = sv[j], sv[i] }
+func (sv encodedKeyValues) Less(i, j int) bool { return sv[i].key < sv[j].key }
diff --git a/vendor/github.com/json-iterator/go/reflect_marshaler.go b/vendor/github.com/json-iterator/go/reflect_marshaler.go
new file mode 100644
index 0000000..3e21f37
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/reflect_marshaler.go
@@ -0,0 +1,225 @@
+package jsoniter
+
+import (
+        "encoding"
+        "encoding/json"
+        "unsafe"
+
+        "github.com/modern-go/reflect2"
+)
+
+var marshalerType = reflect2.TypeOfPtr((*json.Marshaler)(nil)).Elem()
+var unmarshalerType = reflect2.TypeOfPtr((*json.Unmarshaler)(nil)).Elem()
+var textMarshalerType = reflect2.TypeOfPtr((*encoding.TextMarshaler)(nil)).Elem()
+var textUnmarshalerType = reflect2.TypeOfPtr((*encoding.TextUnmarshaler)(nil)).Elem()
+
+func createDecoderOfMarshaler(ctx *ctx, typ reflect2.Type) ValDecoder {
+        ptrType := reflect2.PtrTo(typ)
+        if ptrType.Implements(unmarshalerType) {
+                return &referenceDecoder{
+                        &unmarshalerDecoder{ptrType},
+                }
+        }
+        if ptrType.Implements(textUnmarshalerType) {
+                return &referenceDecoder{
+                        &textUnmarshalerDecoder{ptrType},
+                }
+        }
+        return nil
+}
+
+func createEncoderOfMarshaler(ctx *ctx, typ reflect2.Type) ValEncoder {
+        if typ == marshalerType {
+                checkIsEmpty := createCheckIsEmpty(ctx, typ)
+                var encoder ValEncoder = &directMarshalerEncoder{
+                        checkIsEmpty: checkIsEmpty,
+                }
+                return encoder
+        }
+        if typ.Implements(marshalerType) {
+                checkIsEmpty := createCheckIsEmpty(ctx, typ)
+                var encoder ValEncoder = &marshalerEncoder{
+                        valType:      typ,
+                        checkIsEmpty: checkIsEmpty,
+                }
+                return encoder
+        }
+        ptrType := reflect2.PtrTo(typ)
+        if ctx.prefix != "" && ptrType.Implements(marshalerType) {
+                checkIsEmpty := createCheckIsEmpty(ctx, ptrType)
+                var encoder ValEncoder = &marshalerEncoder{
+                        valType:      ptrType,
+                        checkIsEmpty: checkIsEmpty,
+                }
+                return &referenceEncoder{encoder}
+        }
+        if typ == textMarshalerType {
+                checkIsEmpty := createCheckIsEmpty(ctx, typ)
+                var encoder ValEncoder = &directTextMarshalerEncoder{
+                        checkIsEmpty:  checkIsEmpty,
+                        stringEncoder: ctx.EncoderOf(reflect2.TypeOf("")),
+                }
+                return encoder
+        }
+        if typ.Implements(textMarshalerType) {
+                checkIsEmpty := createCheckIsEmpty(ctx, typ)
+                var encoder ValEncoder = &textMarshalerEncoder{
+                        valType:       typ,
+                        stringEncoder: ctx.EncoderOf(reflect2.TypeOf("")),
+                        checkIsEmpty:  checkIsEmpty,
+                }
+                return encoder
+        }
+        // if prefix is empty, the type is the root type
+        if ctx.prefix != "" && ptrType.Implements(textMarshalerType) {
+                checkIsEmpty := createCheckIsEmpty(ctx, ptrType)
+                var encoder ValEncoder = &textMarshalerEncoder{
+                        valType:       ptrType,
+                        stringEncoder: ctx.EncoderOf(reflect2.TypeOf("")),
+                        checkIsEmpty:  checkIsEmpty,
+                }
+                return &referenceEncoder{encoder}
+        }
+        return nil
+}
+
+type marshalerEncoder struct {
+        checkIsEmpty checkIsEmpty
+        valType      reflect2.Type
+}
+
+func (encoder *marshalerEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        obj := encoder.valType.UnsafeIndirect(ptr)
+        if encoder.valType.IsNullable() && reflect2.IsNil(obj) {
+                stream.WriteNil()
+                return
+        }
+        marshaler := obj.(json.Marshaler)
+        bytes, err := marshaler.MarshalJSON()
+        if err != nil {
+                stream.Error = err
+        } else {
+                // html escape was already done by jsoniter
+                // but the extra '\n' should be trimed
+                l := len(bytes)
+                if l > 0 && bytes[l-1] == '\n' {
+                        bytes = bytes[:l-1]
+                }
+                stream.Write(bytes)
+        }
+}
+
+func (encoder *marshalerEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return encoder.checkIsEmpty.IsEmpty(ptr)
+}
+
+type directMarshalerEncoder struct {
+        checkIsEmpty checkIsEmpty
+}
+
+func (encoder *directMarshalerEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        marshaler := *(*json.Marshaler)(ptr)
+        if marshaler == nil {
+                stream.WriteNil()
+                return
+        }
+        bytes, err := marshaler.MarshalJSON()
+        if err != nil {
+                stream.Error = err
+        } else {
+                stream.Write(bytes)
+        }
+}
+
+func (encoder *directMarshalerEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return encoder.checkIsEmpty.IsEmpty(ptr)
+}
+
+type textMarshalerEncoder struct {
+        valType       reflect2.Type
+        stringEncoder ValEncoder
+        checkIsEmpty  checkIsEmpty
+}
+
+func (encoder *textMarshalerEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        obj := encoder.valType.UnsafeIndirect(ptr)
+        if encoder.valType.IsNullable() && reflect2.IsNil(obj) {
+                stream.WriteNil()
+                return
+        }
+        marshaler := (obj).(encoding.TextMarshaler)
+        bytes, err := marshaler.MarshalText()
+        if err != nil {
+                stream.Error = err
+        } else {
+                str := string(bytes)
+                encoder.stringEncoder.Encode(unsafe.Pointer(&str), stream)
+        }
+}
+
+func (encoder *textMarshalerEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return encoder.checkIsEmpty.IsEmpty(ptr)
+}
+
+type directTextMarshalerEncoder struct {
+        stringEncoder ValEncoder
+        checkIsEmpty  checkIsEmpty
+}
+
+func (encoder *directTextMarshalerEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        marshaler := *(*encoding.TextMarshaler)(ptr)
+        if marshaler == nil {
+                stream.WriteNil()
+                return
+        }
+        bytes, err := marshaler.MarshalText()
+        if err != nil {
+                stream.Error = err
+        } else {
+                str := string(bytes)
+                encoder.stringEncoder.Encode(unsafe.Pointer(&str), stream)
+        }
+}
+
+func (encoder *directTextMarshalerEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return encoder.checkIsEmpty.IsEmpty(ptr)
+}
+
+type unmarshalerDecoder struct {
+        valType reflect2.Type
+}
+
+func (decoder *unmarshalerDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        valType := decoder.valType
+        obj := valType.UnsafeIndirect(ptr)
+        unmarshaler := obj.(json.Unmarshaler)
+        iter.nextToken()
+        iter.unreadByte() // skip spaces
+        bytes := iter.SkipAndReturnBytes()
+        err := unmarshaler.UnmarshalJSON(bytes)
+        if err != nil {
+                iter.ReportError("unmarshalerDecoder", err.Error())
+        }
+}
+
+type textUnmarshalerDecoder struct {
+        valType reflect2.Type
+}
+
+func (decoder *textUnmarshalerDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        valType := decoder.valType
+        obj := valType.UnsafeIndirect(ptr)
+        if reflect2.IsNil(obj) {
+                ptrType := valType.(*reflect2.UnsafePtrType)
+                elemType := ptrType.Elem()
+                elem := elemType.UnsafeNew()
+                ptrType.UnsafeSet(ptr, unsafe.Pointer(&elem))
+                obj = valType.UnsafeIndirect(ptr)
+        }
+        unmarshaler := (obj).(encoding.TextUnmarshaler)
+        str := iter.ReadString()
+        err := unmarshaler.UnmarshalText([]byte(str))
+        if err != nil {
+                iter.ReportError("textUnmarshalerDecoder", err.Error())
+        }
+}
diff --git a/vendor/github.com/json-iterator/go/reflect_native.go b/vendor/github.com/json-iterator/go/reflect_native.go
new file mode 100644
index 0000000..f88722d
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/reflect_native.go
@@ -0,0 +1,453 @@
+package jsoniter
+
+import (
+        "encoding/base64"
+        "reflect"
+        "strconv"
+        "unsafe"
+
+        "github.com/modern-go/reflect2"
+)
+
+const ptrSize = 32 << uintptr(^uintptr(0)>>63)
+
+func createEncoderOfNative(ctx *ctx, typ reflect2.Type) ValEncoder {
+        if typ.Kind() == reflect.Slice && typ.(reflect2.SliceType).Elem().Kind() == reflect.Uint8 {
+                sliceDecoder := decoderOfSlice(ctx, typ)
+                return &base64Codec{sliceDecoder: sliceDecoder}
+        }
+        typeName := typ.String()
+        kind := typ.Kind()
+        switch kind {
+        case reflect.String:
+                if typeName != "string" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*string)(nil)).Elem())
+                }
+                return &stringCodec{}
+        case reflect.Int:
+                if typeName != "int" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*int)(nil)).Elem())
+                }
+                if strconv.IntSize == 32 {
+                        return &int32Codec{}
+                }
+                return &int64Codec{}
+        case reflect.Int8:
+                if typeName != "int8" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*int8)(nil)).Elem())
+                }
+                return &int8Codec{}
+        case reflect.Int16:
+                if typeName != "int16" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*int16)(nil)).Elem())
+                }
+                return &int16Codec{}
+        case reflect.Int32:
+                if typeName != "int32" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*int32)(nil)).Elem())
+                }
+                return &int32Codec{}
+        case reflect.Int64:
+                if typeName != "int64" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*int64)(nil)).Elem())
+                }
+                return &int64Codec{}
+        case reflect.Uint:
+                if typeName != "uint" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*uint)(nil)).Elem())
+                }
+                if strconv.IntSize == 32 {
+                        return &uint32Codec{}
+                }
+                return &uint64Codec{}
+        case reflect.Uint8:
+                if typeName != "uint8" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*uint8)(nil)).Elem())
+                }
+                return &uint8Codec{}
+        case reflect.Uint16:
+                if typeName != "uint16" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*uint16)(nil)).Elem())
+                }
+                return &uint16Codec{}
+        case reflect.Uint32:
+                if typeName != "uint32" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*uint32)(nil)).Elem())
+                }
+                return &uint32Codec{}
+        case reflect.Uintptr:
+                if typeName != "uintptr" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*uintptr)(nil)).Elem())
+                }
+                if ptrSize == 32 {
+                        return &uint32Codec{}
+                }
+                return &uint64Codec{}
+        case reflect.Uint64:
+                if typeName != "uint64" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*uint64)(nil)).Elem())
+                }
+                return &uint64Codec{}
+        case reflect.Float32:
+                if typeName != "float32" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*float32)(nil)).Elem())
+                }
+                return &float32Codec{}
+        case reflect.Float64:
+                if typeName != "float64" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*float64)(nil)).Elem())
+                }
+                return &float64Codec{}
+        case reflect.Bool:
+                if typeName != "bool" {
+                        return encoderOfType(ctx, reflect2.TypeOfPtr((*bool)(nil)).Elem())
+                }
+                return &boolCodec{}
+        }
+        return nil
+}
+
+func createDecoderOfNative(ctx *ctx, typ reflect2.Type) ValDecoder {
+        if typ.Kind() == reflect.Slice && typ.(reflect2.SliceType).Elem().Kind() == reflect.Uint8 {
+                sliceDecoder := decoderOfSlice(ctx, typ)
+                return &base64Codec{sliceDecoder: sliceDecoder}
+        }
+        typeName := typ.String()
+        switch typ.Kind() {
+        case reflect.String:
+                if typeName != "string" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*string)(nil)).Elem())
+                }
+                return &stringCodec{}
+        case reflect.Int:
+                if typeName != "int" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*int)(nil)).Elem())
+                }
+                if strconv.IntSize == 32 {
+                        return &int32Codec{}
+                }
+                return &int64Codec{}
+        case reflect.Int8:
+                if typeName != "int8" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*int8)(nil)).Elem())
+                }
+                return &int8Codec{}
+        case reflect.Int16:
+                if typeName != "int16" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*int16)(nil)).Elem())
+                }
+                return &int16Codec{}
+        case reflect.Int32:
+                if typeName != "int32" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*int32)(nil)).Elem())
+                }
+                return &int32Codec{}
+        case reflect.Int64:
+                if typeName != "int64" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*int64)(nil)).Elem())
+                }
+                return &int64Codec{}
+        case reflect.Uint:
+                if typeName != "uint" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*uint)(nil)).Elem())
+                }
+                if strconv.IntSize == 32 {
+                        return &uint32Codec{}
+                }
+                return &uint64Codec{}
+        case reflect.Uint8:
+                if typeName != "uint8" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*uint8)(nil)).Elem())
+                }
+                return &uint8Codec{}
+        case reflect.Uint16:
+                if typeName != "uint16" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*uint16)(nil)).Elem())
+                }
+                return &uint16Codec{}
+        case reflect.Uint32:
+                if typeName != "uint32" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*uint32)(nil)).Elem())
+                }
+                return &uint32Codec{}
+        case reflect.Uintptr:
+                if typeName != "uintptr" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*uintptr)(nil)).Elem())
+                }
+                if ptrSize == 32 {
+                        return &uint32Codec{}
+                }
+                return &uint64Codec{}
+        case reflect.Uint64:
+                if typeName != "uint64" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*uint64)(nil)).Elem())
+                }
+                return &uint64Codec{}
+        case reflect.Float32:
+                if typeName != "float32" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*float32)(nil)).Elem())
+                }
+                return &float32Codec{}
+        case reflect.Float64:
+                if typeName != "float64" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*float64)(nil)).Elem())
+                }
+                return &float64Codec{}
+        case reflect.Bool:
+                if typeName != "bool" {
+                        return decoderOfType(ctx, reflect2.TypeOfPtr((*bool)(nil)).Elem())
+                }
+                return &boolCodec{}
+        }
+        return nil
+}
+
+type stringCodec struct {
+}
+
+func (codec *stringCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        *((*string)(ptr)) = iter.ReadString()
+}
+
+func (codec *stringCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        str := *((*string)(ptr))
+        stream.WriteString(str)
+}
+
+func (codec *stringCodec) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*string)(ptr)) == ""
+}
+
+type int8Codec struct {
+}
+
+func (codec *int8Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.ReadNil() {
+                *((*int8)(ptr)) = iter.ReadInt8()
+        }
+}
+
+func (codec *int8Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteInt8(*((*int8)(ptr)))
+}
+
+func (codec *int8Codec) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*int8)(ptr)) == 0
+}
+
+type int16Codec struct {
+}
+
+func (codec *int16Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.ReadNil() {
+                *((*int16)(ptr)) = iter.ReadInt16()
+        }
+}
+
+func (codec *int16Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteInt16(*((*int16)(ptr)))
+}
+
+func (codec *int16Codec) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*int16)(ptr)) == 0
+}
+
+type int32Codec struct {
+}
+
+func (codec *int32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.ReadNil() {
+                *((*int32)(ptr)) = iter.ReadInt32()
+        }
+}
+
+func (codec *int32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteInt32(*((*int32)(ptr)))
+}
+
+func (codec *int32Codec) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*int32)(ptr)) == 0
+}
+
+type int64Codec struct {
+}
+
+func (codec *int64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.ReadNil() {
+                *((*int64)(ptr)) = iter.ReadInt64()
+        }
+}
+
+func (codec *int64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteInt64(*((*int64)(ptr)))
+}
+
+func (codec *int64Codec) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*int64)(ptr)) == 0
+}
+
+type uint8Codec struct {
+}
+
+func (codec *uint8Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.ReadNil() {
+                *((*uint8)(ptr)) = iter.ReadUint8()
+        }
+}
+
+func (codec *uint8Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteUint8(*((*uint8)(ptr)))
+}
+
+func (codec *uint8Codec) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*uint8)(ptr)) == 0
+}
+
+type uint16Codec struct {
+}
+
+func (codec *uint16Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.ReadNil() {
+                *((*uint16)(ptr)) = iter.ReadUint16()
+        }
+}
+
+func (codec *uint16Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteUint16(*((*uint16)(ptr)))
+}
+
+func (codec *uint16Codec) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*uint16)(ptr)) == 0
+}
+
+type uint32Codec struct {
+}
+
+func (codec *uint32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.ReadNil() {
+                *((*uint32)(ptr)) = iter.ReadUint32()
+        }
+}
+
+func (codec *uint32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteUint32(*((*uint32)(ptr)))
+}
+
+func (codec *uint32Codec) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*uint32)(ptr)) == 0
+}
+
+type uint64Codec struct {
+}
+
+func (codec *uint64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.ReadNil() {
+                *((*uint64)(ptr)) = iter.ReadUint64()
+        }
+}
+
+func (codec *uint64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteUint64(*((*uint64)(ptr)))
+}
+
+func (codec *uint64Codec) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*uint64)(ptr)) == 0
+}
+
+type float32Codec struct {
+}
+
+func (codec *float32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.ReadNil() {
+                *((*float32)(ptr)) = iter.ReadFloat32()
+        }
+}
+
+func (codec *float32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteFloat32(*((*float32)(ptr)))
+}
+
+func (codec *float32Codec) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*float32)(ptr)) == 0
+}
+
+type float64Codec struct {
+}
+
+func (codec *float64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.ReadNil() {
+                *((*float64)(ptr)) = iter.ReadFloat64()
+        }
+}
+
+func (codec *float64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteFloat64(*((*float64)(ptr)))
+}
+
+func (codec *float64Codec) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*float64)(ptr)) == 0
+}
+
+type boolCodec struct {
+}
+
+func (codec *boolCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.ReadNil() {
+                *((*bool)(ptr)) = iter.ReadBool()
+        }
+}
+
+func (codec *boolCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteBool(*((*bool)(ptr)))
+}
+
+func (codec *boolCodec) IsEmpty(ptr unsafe.Pointer) bool {
+        return !(*((*bool)(ptr)))
+}
+
+type base64Codec struct {
+        sliceType    *reflect2.UnsafeSliceType
+        sliceDecoder ValDecoder
+}
+
+func (codec *base64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if iter.ReadNil() {
+                codec.sliceType.UnsafeSetNil(ptr)
+                return
+        }
+        switch iter.WhatIsNext() {
+        case StringValue:
+                src := iter.ReadString()
+                dst, err := base64.StdEncoding.DecodeString(src)
+                if err != nil {
+                        iter.ReportError("decode base64", err.Error())
+                } else {
+                        codec.sliceType.UnsafeSet(ptr, unsafe.Pointer(&dst))
+                }
+        case ArrayValue:
+                codec.sliceDecoder.Decode(ptr, iter)
+        default:
+                iter.ReportError("base64Codec", "invalid input")
+        }
+}
+
+func (codec *base64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
+        if codec.sliceType.UnsafeIsNil(ptr) {
+                stream.WriteNil()
+                return
+        }
+        src := *((*[]byte)(ptr))
+        encoding := base64.StdEncoding
+        stream.writeByte('"')
+        if len(src) != 0 {
+                size := encoding.EncodedLen(len(src))
+                buf := make([]byte, size)
+                encoding.Encode(buf, src)
+                stream.buf = append(stream.buf, buf...)
+        }
+        stream.writeByte('"')
+}
+
+func (codec *base64Codec) IsEmpty(ptr unsafe.Pointer) bool {
+        return len(*((*[]byte)(ptr))) == 0
+}
diff --git a/vendor/github.com/json-iterator/go/reflect_optional.go b/vendor/github.com/json-iterator/go/reflect_optional.go
new file mode 100644
index 0000000..fa71f47
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/reflect_optional.go
@@ -0,0 +1,129 @@
+package jsoniter
+
+import (
+        "github.com/modern-go/reflect2"
+        "unsafe"
+)
+
+func decoderOfOptional(ctx *ctx, typ reflect2.Type) ValDecoder {
+        ptrType := typ.(*reflect2.UnsafePtrType)
+        elemType := ptrType.Elem()
+        decoder := decoderOfType(ctx, elemType)
+        return &OptionalDecoder{elemType, decoder}
+}
+
+func encoderOfOptional(ctx *ctx, typ reflect2.Type) ValEncoder {
+        ptrType := typ.(*reflect2.UnsafePtrType)
+        elemType := ptrType.Elem()
+        elemEncoder := encoderOfType(ctx, elemType)
+        encoder := &OptionalEncoder{elemEncoder}
+        return encoder
+}
+
+type OptionalDecoder struct {
+        ValueType    reflect2.Type
+        ValueDecoder ValDecoder
+}
+
+func (decoder *OptionalDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if iter.ReadNil() {
+                *((*unsafe.Pointer)(ptr)) = nil
+        } else {
+                if *((*unsafe.Pointer)(ptr)) == nil {
+                        //pointer to null, we have to allocate memory to hold the value
+                        newPtr := decoder.ValueType.UnsafeNew()
+                        decoder.ValueDecoder.Decode(newPtr, iter)
+                        *((*unsafe.Pointer)(ptr)) = newPtr
+                } else {
+                        //reuse existing instance
+                        decoder.ValueDecoder.Decode(*((*unsafe.Pointer)(ptr)), iter)
+                }
+        }
+}
+
+type dereferenceDecoder struct {
+        // only to deference a pointer
+        valueType    reflect2.Type
+        valueDecoder ValDecoder
+}
+
+func (decoder *dereferenceDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if *((*unsafe.Pointer)(ptr)) == nil {
+                //pointer to null, we have to allocate memory to hold the value
+                newPtr := decoder.valueType.UnsafeNew()
+                decoder.valueDecoder.Decode(newPtr, iter)
+                *((*unsafe.Pointer)(ptr)) = newPtr
+        } else {
+                //reuse existing instance
+                decoder.valueDecoder.Decode(*((*unsafe.Pointer)(ptr)), iter)
+        }
+}
+
+type OptionalEncoder struct {
+        ValueEncoder ValEncoder
+}
+
+func (encoder *OptionalEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        if *((*unsafe.Pointer)(ptr)) == nil {
+                stream.WriteNil()
+        } else {
+                encoder.ValueEncoder.Encode(*((*unsafe.Pointer)(ptr)), stream)
+        }
+}
+
+func (encoder *OptionalEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return *((*unsafe.Pointer)(ptr)) == nil
+}
+
+type dereferenceEncoder struct {
+        ValueEncoder ValEncoder
+}
+
+func (encoder *dereferenceEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        if *((*unsafe.Pointer)(ptr)) == nil {
+                stream.WriteNil()
+        } else {
+                encoder.ValueEncoder.Encode(*((*unsafe.Pointer)(ptr)), stream)
+        }
+}
+
+func (encoder *dereferenceEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        dePtr := *((*unsafe.Pointer)(ptr))
+        if dePtr == nil {
+                return true
+        }
+        return encoder.ValueEncoder.IsEmpty(dePtr)
+}
+
+func (encoder *dereferenceEncoder) IsEmbeddedPtrNil(ptr unsafe.Pointer) bool {
+        deReferenced := *((*unsafe.Pointer)(ptr))
+        if deReferenced == nil {
+                return true
+        }
+        isEmbeddedPtrNil, converted := encoder.ValueEncoder.(IsEmbeddedPtrNil)
+        if !converted {
+                return false
+        }
+        fieldPtr := unsafe.Pointer(deReferenced)
+        return isEmbeddedPtrNil.IsEmbeddedPtrNil(fieldPtr)
+}
+
+type referenceEncoder struct {
+        encoder ValEncoder
+}
+
+func (encoder *referenceEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        encoder.encoder.Encode(unsafe.Pointer(&ptr), stream)
+}
+
+func (encoder *referenceEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return encoder.encoder.IsEmpty(unsafe.Pointer(&ptr))
+}
+
+type referenceDecoder struct {
+        decoder ValDecoder
+}
+
+func (decoder *referenceDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        decoder.decoder.Decode(unsafe.Pointer(&ptr), iter)
+}
diff --git a/vendor/github.com/json-iterator/go/reflect_slice.go b/vendor/github.com/json-iterator/go/reflect_slice.go
new file mode 100644
index 0000000..9441d79
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/reflect_slice.go
@@ -0,0 +1,99 @@
+package jsoniter
+
+import (
+        "fmt"
+        "github.com/modern-go/reflect2"
+        "io"
+        "unsafe"
+)
+
+func decoderOfSlice(ctx *ctx, typ reflect2.Type) ValDecoder {
+        sliceType := typ.(*reflect2.UnsafeSliceType)
+        decoder := decoderOfType(ctx.append("[sliceElem]"), sliceType.Elem())
+        return &sliceDecoder{sliceType, decoder}
+}
+
+func encoderOfSlice(ctx *ctx, typ reflect2.Type) ValEncoder {
+        sliceType := typ.(*reflect2.UnsafeSliceType)
+        encoder := encoderOfType(ctx.append("[sliceElem]"), sliceType.Elem())
+        return &sliceEncoder{sliceType, encoder}
+}
+
+type sliceEncoder struct {
+        sliceType   *reflect2.UnsafeSliceType
+        elemEncoder ValEncoder
+}
+
+func (encoder *sliceEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        if encoder.sliceType.UnsafeIsNil(ptr) {
+                stream.WriteNil()
+                return
+        }
+        length := encoder.sliceType.UnsafeLengthOf(ptr)
+        if length == 0 {
+                stream.WriteEmptyArray()
+                return
+        }
+        stream.WriteArrayStart()
+        encoder.elemEncoder.Encode(encoder.sliceType.UnsafeGetIndex(ptr, 0), stream)
+        for i := 1; i < length; i++ {
+                stream.WriteMore()
+                elemPtr := encoder.sliceType.UnsafeGetIndex(ptr, i)
+                encoder.elemEncoder.Encode(elemPtr, stream)
+        }
+        stream.WriteArrayEnd()
+        if stream.Error != nil && stream.Error != io.EOF {
+                stream.Error = fmt.Errorf("%v: %s", encoder.sliceType, stream.Error.Error())
+        }
+}
+
+func (encoder *sliceEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return encoder.sliceType.UnsafeLengthOf(ptr) == 0
+}
+
+type sliceDecoder struct {
+        sliceType   *reflect2.UnsafeSliceType
+        elemDecoder ValDecoder
+}
+
+func (decoder *sliceDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        decoder.doDecode(ptr, iter)
+        if iter.Error != nil && iter.Error != io.EOF {
+                iter.Error = fmt.Errorf("%v: %s", decoder.sliceType, iter.Error.Error())
+        }
+}
+
+func (decoder *sliceDecoder) doDecode(ptr unsafe.Pointer, iter *Iterator) {
+        c := iter.nextToken()
+        sliceType := decoder.sliceType
+        if c == 'n' {
+                iter.skipThreeBytes('u', 'l', 'l')
+                sliceType.UnsafeSetNil(ptr)
+                return
+        }
+        if c != '[' {
+                iter.ReportError("decode slice", "expect [ or n, but found "+string([]byte{c}))
+                return
+        }
+        c = iter.nextToken()
+        if c == ']' {
+                sliceType.UnsafeSet(ptr, sliceType.UnsafeMakeSlice(0, 0))
+                return
+        }
+        iter.unreadByte()
+        sliceType.UnsafeGrow(ptr, 1)
+        elemPtr := sliceType.UnsafeGetIndex(ptr, 0)
+        decoder.elemDecoder.Decode(elemPtr, iter)
+        length := 1
+        for c = iter.nextToken(); c == ','; c = iter.nextToken() {
+                idx := length
+                length += 1
+                sliceType.UnsafeGrow(ptr, length)
+                elemPtr = sliceType.UnsafeGetIndex(ptr, idx)
+                decoder.elemDecoder.Decode(elemPtr, iter)
+        }
+        if c != ']' {
+                iter.ReportError("decode slice", "expect ], but found "+string([]byte{c}))
+                return
+        }
+}
diff --git a/vendor/github.com/json-iterator/go/reflect_struct_decoder.go b/vendor/github.com/json-iterator/go/reflect_struct_decoder.go
new file mode 100644
index 0000000..92ae912
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/reflect_struct_decoder.go
@@ -0,0 +1,1097 @@
+package jsoniter
+
+import (
+        "fmt"
+        "io"
+        "strings"
+        "unsafe"
+
+        "github.com/modern-go/reflect2"
+)
+
+func decoderOfStruct(ctx *ctx, typ reflect2.Type) ValDecoder {
+        bindings := map[string]*Binding{}
+        structDescriptor := describeStruct(ctx, typ)
+        for _, binding := range structDescriptor.Fields {
+                for _, fromName := range binding.FromNames {
+                        old := bindings[fromName]
+                        if old == nil {
+                                bindings[fromName] = binding
+                                continue
+                        }
+                        ignoreOld, ignoreNew := resolveConflictBinding(ctx.frozenConfig, old, binding)
+                        if ignoreOld {
+                                delete(bindings, fromName)
+                        }
+                        if !ignoreNew {
+                                bindings[fromName] = binding
+                        }
+                }
+        }
+        fields := map[string]*structFieldDecoder{}
+        for k, binding := range bindings {
+                fields[k] = binding.Decoder.(*structFieldDecoder)
+        }
+
+        if !ctx.caseSensitive() {
+                for k, binding := range bindings {
+                        if _, found := fields[strings.ToLower(k)]; !found {
+                                fields[strings.ToLower(k)] = binding.Decoder.(*structFieldDecoder)
+                        }
+                }
+        }
+
+        return createStructDecoder(ctx, typ, fields)
+}
+
+func createStructDecoder(ctx *ctx, typ reflect2.Type, fields map[string]*structFieldDecoder) ValDecoder {
+        if ctx.disallowUnknownFields {
+                return &generalStructDecoder{typ: typ, fields: fields, disallowUnknownFields: true}
+        }
+        knownHash := map[int64]struct{}{
+                0: {},
+        }
+
+        switch len(fields) {
+        case 0:
+                return &skipObjectDecoder{typ}
+        case 1:
+                for fieldName, fieldDecoder := range fields {
+                        fieldHash := calcHash(fieldName, ctx.caseSensitive())
+                        _, known := knownHash[fieldHash]
+                        if known {
+                                return &generalStructDecoder{typ, fields, false}
+                        }
+                        knownHash[fieldHash] = struct{}{}
+                        return &oneFieldStructDecoder{typ, fieldHash, fieldDecoder}
+                }
+        case 2:
+                var fieldHash1 int64
+                var fieldHash2 int64
+                var fieldDecoder1 *structFieldDecoder
+                var fieldDecoder2 *structFieldDecoder
+                for fieldName, fieldDecoder := range fields {
+                        fieldHash := calcHash(fieldName, ctx.caseSensitive())
+                        _, known := knownHash[fieldHash]
+                        if known {
+                                return &generalStructDecoder{typ, fields, false}
+                        }
+                        knownHash[fieldHash] = struct{}{}
+                        if fieldHash1 == 0 {
+                                fieldHash1 = fieldHash
+                                fieldDecoder1 = fieldDecoder
+                        } else {
+                                fieldHash2 = fieldHash
+                                fieldDecoder2 = fieldDecoder
+                        }
+                }
+                return &twoFieldsStructDecoder{typ, fieldHash1, fieldDecoder1, fieldHash2, fieldDecoder2}
+        case 3:
+                var fieldName1 int64
+                var fieldName2 int64
+                var fieldName3 int64
+                var fieldDecoder1 *structFieldDecoder
+                var fieldDecoder2 *structFieldDecoder
+                var fieldDecoder3 *structFieldDecoder
+                for fieldName, fieldDecoder := range fields {
+                        fieldHash := calcHash(fieldName, ctx.caseSensitive())
+                        _, known := knownHash[fieldHash]
+                        if known {
+                                return &generalStructDecoder{typ, fields, false}
+                        }
+                        knownHash[fieldHash] = struct{}{}
+                        if fieldName1 == 0 {
+                                fieldName1 = fieldHash
+                                fieldDecoder1 = fieldDecoder
+                        } else if fieldName2 == 0 {
+                                fieldName2 = fieldHash
+                                fieldDecoder2 = fieldDecoder
+                        } else {
+                                fieldName3 = fieldHash
+                                fieldDecoder3 = fieldDecoder
+                        }
+                }
+                return &threeFieldsStructDecoder{typ,
+                        fieldName1, fieldDecoder1,
+                        fieldName2, fieldDecoder2,
+                        fieldName3, fieldDecoder3}
+        case 4:
+                var fieldName1 int64
+                var fieldName2 int64
+                var fieldName3 int64
+                var fieldName4 int64
+                var fieldDecoder1 *structFieldDecoder
+                var fieldDecoder2 *structFieldDecoder
+                var fieldDecoder3 *structFieldDecoder
+                var fieldDecoder4 *structFieldDecoder
+                for fieldName, fieldDecoder := range fields {
+                        fieldHash := calcHash(fieldName, ctx.caseSensitive())
+                        _, known := knownHash[fieldHash]
+                        if known {
+                                return &generalStructDecoder{typ, fields, false}
+                        }
+                        knownHash[fieldHash] = struct{}{}
+                        if fieldName1 == 0 {
+                                fieldName1 = fieldHash
+                                fieldDecoder1 = fieldDecoder
+                        } else if fieldName2 == 0 {
+                                fieldName2 = fieldHash
+                                fieldDecoder2 = fieldDecoder
+                        } else if fieldName3 == 0 {
+                                fieldName3 = fieldHash
+                                fieldDecoder3 = fieldDecoder
+                        } else {
+                                fieldName4 = fieldHash
+                                fieldDecoder4 = fieldDecoder
+                        }
+                }
+                return &fourFieldsStructDecoder{typ,
+                        fieldName1, fieldDecoder1,
+                        fieldName2, fieldDecoder2,
+                        fieldName3, fieldDecoder3,
+                        fieldName4, fieldDecoder4}
+        case 5:
+                var fieldName1 int64
+                var fieldName2 int64
+                var fieldName3 int64
+                var fieldName4 int64
+                var fieldName5 int64
+                var fieldDecoder1 *structFieldDecoder
+                var fieldDecoder2 *structFieldDecoder
+                var fieldDecoder3 *structFieldDecoder
+                var fieldDecoder4 *structFieldDecoder
+                var fieldDecoder5 *structFieldDecoder
+                for fieldName, fieldDecoder := range fields {
+                        fieldHash := calcHash(fieldName, ctx.caseSensitive())
+                        _, known := knownHash[fieldHash]
+                        if known {
+                                return &generalStructDecoder{typ, fields, false}
+                        }
+                        knownHash[fieldHash] = struct{}{}
+                        if fieldName1 == 0 {
+                                fieldName1 = fieldHash
+                                fieldDecoder1 = fieldDecoder
+                        } else if fieldName2 == 0 {
+                                fieldName2 = fieldHash
+                                fieldDecoder2 = fieldDecoder
+                        } else if fieldName3 == 0 {
+                                fieldName3 = fieldHash
+                                fieldDecoder3 = fieldDecoder
+                        } else if fieldName4 == 0 {
+                                fieldName4 = fieldHash
+                                fieldDecoder4 = fieldDecoder
+                        } else {
+                                fieldName5 = fieldHash
+                                fieldDecoder5 = fieldDecoder
+                        }
+                }
+                return &fiveFieldsStructDecoder{typ,
+                        fieldName1, fieldDecoder1,
+                        fieldName2, fieldDecoder2,
+                        fieldName3, fieldDecoder3,
+                        fieldName4, fieldDecoder4,
+                        fieldName5, fieldDecoder5}
+        case 6:
+                var fieldName1 int64
+                var fieldName2 int64
+                var fieldName3 int64
+                var fieldName4 int64
+                var fieldName5 int64
+                var fieldName6 int64
+                var fieldDecoder1 *structFieldDecoder
+                var fieldDecoder2 *structFieldDecoder
+                var fieldDecoder3 *structFieldDecoder
+                var fieldDecoder4 *structFieldDecoder
+                var fieldDecoder5 *structFieldDecoder
+                var fieldDecoder6 *structFieldDecoder
+                for fieldName, fieldDecoder := range fields {
+                        fieldHash := calcHash(fieldName, ctx.caseSensitive())
+                        _, known := knownHash[fieldHash]
+                        if known {
+                                return &generalStructDecoder{typ, fields, false}
+                        }
+                        knownHash[fieldHash] = struct{}{}
+                        if fieldName1 == 0 {
+                                fieldName1 = fieldHash
+                                fieldDecoder1 = fieldDecoder
+                        } else if fieldName2 == 0 {
+                                fieldName2 = fieldHash
+                                fieldDecoder2 = fieldDecoder
+                        } else if fieldName3 == 0 {
+                                fieldName3 = fieldHash
+                                fieldDecoder3 = fieldDecoder
+                        } else if fieldName4 == 0 {
+                                fieldName4 = fieldHash
+                                fieldDecoder4 = fieldDecoder
+                        } else if fieldName5 == 0 {
+                                fieldName5 = fieldHash
+                                fieldDecoder5 = fieldDecoder
+                        } else {
+                                fieldName6 = fieldHash
+                                fieldDecoder6 = fieldDecoder
+                        }
+                }
+                return &sixFieldsStructDecoder{typ,
+                        fieldName1, fieldDecoder1,
+                        fieldName2, fieldDecoder2,
+                        fieldName3, fieldDecoder3,
+                        fieldName4, fieldDecoder4,
+                        fieldName5, fieldDecoder5,
+                        fieldName6, fieldDecoder6}
+        case 7:
+                var fieldName1 int64
+                var fieldName2 int64
+                var fieldName3 int64
+                var fieldName4 int64
+                var fieldName5 int64
+                var fieldName6 int64
+                var fieldName7 int64
+                var fieldDecoder1 *structFieldDecoder
+                var fieldDecoder2 *structFieldDecoder
+                var fieldDecoder3 *structFieldDecoder
+                var fieldDecoder4 *structFieldDecoder
+                var fieldDecoder5 *structFieldDecoder
+                var fieldDecoder6 *structFieldDecoder
+                var fieldDecoder7 *structFieldDecoder
+                for fieldName, fieldDecoder := range fields {
+                        fieldHash := calcHash(fieldName, ctx.caseSensitive())
+                        _, known := knownHash[fieldHash]
+                        if known {
+                                return &generalStructDecoder{typ, fields, false}
+                        }
+                        knownHash[fieldHash] = struct{}{}
+                        if fieldName1 == 0 {
+                                fieldName1 = fieldHash
+                                fieldDecoder1 = fieldDecoder
+                        } else if fieldName2 == 0 {
+                                fieldName2 = fieldHash
+                                fieldDecoder2 = fieldDecoder
+                        } else if fieldName3 == 0 {
+                                fieldName3 = fieldHash
+                                fieldDecoder3 = fieldDecoder
+                        } else if fieldName4 == 0 {
+                                fieldName4 = fieldHash
+                                fieldDecoder4 = fieldDecoder
+                        } else if fieldName5 == 0 {
+                                fieldName5 = fieldHash
+                                fieldDecoder5 = fieldDecoder
+                        } else if fieldName6 == 0 {
+                                fieldName6 = fieldHash
+                                fieldDecoder6 = fieldDecoder
+                        } else {
+                                fieldName7 = fieldHash
+                                fieldDecoder7 = fieldDecoder
+                        }
+                }
+                return &sevenFieldsStructDecoder{typ,
+                        fieldName1, fieldDecoder1,
+                        fieldName2, fieldDecoder2,
+                        fieldName3, fieldDecoder3,
+                        fieldName4, fieldDecoder4,
+                        fieldName5, fieldDecoder5,
+                        fieldName6, fieldDecoder6,
+                        fieldName7, fieldDecoder7}
+        case 8:
+                var fieldName1 int64
+                var fieldName2 int64
+                var fieldName3 int64
+                var fieldName4 int64
+                var fieldName5 int64
+                var fieldName6 int64
+                var fieldName7 int64
+                var fieldName8 int64
+                var fieldDecoder1 *structFieldDecoder
+                var fieldDecoder2 *structFieldDecoder
+                var fieldDecoder3 *structFieldDecoder
+                var fieldDecoder4 *structFieldDecoder
+                var fieldDecoder5 *structFieldDecoder
+                var fieldDecoder6 *structFieldDecoder
+                var fieldDecoder7 *structFieldDecoder
+                var fieldDecoder8 *structFieldDecoder
+                for fieldName, fieldDecoder := range fields {
+                        fieldHash := calcHash(fieldName, ctx.caseSensitive())
+                        _, known := knownHash[fieldHash]
+                        if known {
+                                return &generalStructDecoder{typ, fields, false}
+                        }
+                        knownHash[fieldHash] = struct{}{}
+                        if fieldName1 == 0 {
+                                fieldName1 = fieldHash
+                                fieldDecoder1 = fieldDecoder
+                        } else if fieldName2 == 0 {
+                                fieldName2 = fieldHash
+                                fieldDecoder2 = fieldDecoder
+                        } else if fieldName3 == 0 {
+                                fieldName3 = fieldHash
+                                fieldDecoder3 = fieldDecoder
+                        } else if fieldName4 == 0 {
+                                fieldName4 = fieldHash
+                                fieldDecoder4 = fieldDecoder
+                        } else if fieldName5 == 0 {
+                                fieldName5 = fieldHash
+                                fieldDecoder5 = fieldDecoder
+                        } else if fieldName6 == 0 {
+                                fieldName6 = fieldHash
+                                fieldDecoder6 = fieldDecoder
+                        } else if fieldName7 == 0 {
+                                fieldName7 = fieldHash
+                                fieldDecoder7 = fieldDecoder
+                        } else {
+                                fieldName8 = fieldHash
+                                fieldDecoder8 = fieldDecoder
+                        }
+                }
+                return &eightFieldsStructDecoder{typ,
+                        fieldName1, fieldDecoder1,
+                        fieldName2, fieldDecoder2,
+                        fieldName3, fieldDecoder3,
+                        fieldName4, fieldDecoder4,
+                        fieldName5, fieldDecoder5,
+                        fieldName6, fieldDecoder6,
+                        fieldName7, fieldDecoder7,
+                        fieldName8, fieldDecoder8}
+        case 9:
+                var fieldName1 int64
+                var fieldName2 int64
+                var fieldName3 int64
+                var fieldName4 int64
+                var fieldName5 int64
+                var fieldName6 int64
+                var fieldName7 int64
+                var fieldName8 int64
+                var fieldName9 int64
+                var fieldDecoder1 *structFieldDecoder
+                var fieldDecoder2 *structFieldDecoder
+                var fieldDecoder3 *structFieldDecoder
+                var fieldDecoder4 *structFieldDecoder
+                var fieldDecoder5 *structFieldDecoder
+                var fieldDecoder6 *structFieldDecoder
+                var fieldDecoder7 *structFieldDecoder
+                var fieldDecoder8 *structFieldDecoder
+                var fieldDecoder9 *structFieldDecoder
+                for fieldName, fieldDecoder := range fields {
+                        fieldHash := calcHash(fieldName, ctx.caseSensitive())
+                        _, known := knownHash[fieldHash]
+                        if known {
+                                return &generalStructDecoder{typ, fields, false}
+                        }
+                        knownHash[fieldHash] = struct{}{}
+                        if fieldName1 == 0 {
+                                fieldName1 = fieldHash
+                                fieldDecoder1 = fieldDecoder
+                        } else if fieldName2 == 0 {
+                                fieldName2 = fieldHash
+                                fieldDecoder2 = fieldDecoder
+                        } else if fieldName3 == 0 {
+                                fieldName3 = fieldHash
+                                fieldDecoder3 = fieldDecoder
+                        } else if fieldName4 == 0 {
+                                fieldName4 = fieldHash
+                                fieldDecoder4 = fieldDecoder
+                        } else if fieldName5 == 0 {
+                                fieldName5 = fieldHash
+                                fieldDecoder5 = fieldDecoder
+                        } else if fieldName6 == 0 {
+                                fieldName6 = fieldHash
+                                fieldDecoder6 = fieldDecoder
+                        } else if fieldName7 == 0 {
+                                fieldName7 = fieldHash
+                                fieldDecoder7 = fieldDecoder
+                        } else if fieldName8 == 0 {
+                                fieldName8 = fieldHash
+                                fieldDecoder8 = fieldDecoder
+                        } else {
+                                fieldName9 = fieldHash
+                                fieldDecoder9 = fieldDecoder
+                        }
+                }
+                return &nineFieldsStructDecoder{typ,
+                        fieldName1, fieldDecoder1,
+                        fieldName2, fieldDecoder2,
+                        fieldName3, fieldDecoder3,
+                        fieldName4, fieldDecoder4,
+                        fieldName5, fieldDecoder5,
+                        fieldName6, fieldDecoder6,
+                        fieldName7, fieldDecoder7,
+                        fieldName8, fieldDecoder8,
+                        fieldName9, fieldDecoder9}
+        case 10:
+                var fieldName1 int64
+                var fieldName2 int64
+                var fieldName3 int64
+                var fieldName4 int64
+                var fieldName5 int64
+                var fieldName6 int64
+                var fieldName7 int64
+                var fieldName8 int64
+                var fieldName9 int64
+                var fieldName10 int64
+                var fieldDecoder1 *structFieldDecoder
+                var fieldDecoder2 *structFieldDecoder
+                var fieldDecoder3 *structFieldDecoder
+                var fieldDecoder4 *structFieldDecoder
+                var fieldDecoder5 *structFieldDecoder
+                var fieldDecoder6 *structFieldDecoder
+                var fieldDecoder7 *structFieldDecoder
+                var fieldDecoder8 *structFieldDecoder
+                var fieldDecoder9 *structFieldDecoder
+                var fieldDecoder10 *structFieldDecoder
+                for fieldName, fieldDecoder := range fields {
+                        fieldHash := calcHash(fieldName, ctx.caseSensitive())
+                        _, known := knownHash[fieldHash]
+                        if known {
+                                return &generalStructDecoder{typ, fields, false}
+                        }
+                        knownHash[fieldHash] = struct{}{}
+                        if fieldName1 == 0 {
+                                fieldName1 = fieldHash
+                                fieldDecoder1 = fieldDecoder
+                        } else if fieldName2 == 0 {
+                                fieldName2 = fieldHash
+                                fieldDecoder2 = fieldDecoder
+                        } else if fieldName3 == 0 {
+                                fieldName3 = fieldHash
+                                fieldDecoder3 = fieldDecoder
+                        } else if fieldName4 == 0 {
+                                fieldName4 = fieldHash
+                                fieldDecoder4 = fieldDecoder
+                        } else if fieldName5 == 0 {
+                                fieldName5 = fieldHash
+                                fieldDecoder5 = fieldDecoder
+                        } else if fieldName6 == 0 {
+                                fieldName6 = fieldHash
+                                fieldDecoder6 = fieldDecoder
+                        } else if fieldName7 == 0 {
+                                fieldName7 = fieldHash
+                                fieldDecoder7 = fieldDecoder
+                        } else if fieldName8 == 0 {
+                                fieldName8 = fieldHash
+                                fieldDecoder8 = fieldDecoder
+                        } else if fieldName9 == 0 {
+                                fieldName9 = fieldHash
+                                fieldDecoder9 = fieldDecoder
+                        } else {
+                                fieldName10 = fieldHash
+                                fieldDecoder10 = fieldDecoder
+                        }
+                }
+                return &tenFieldsStructDecoder{typ,
+                        fieldName1, fieldDecoder1,
+                        fieldName2, fieldDecoder2,
+                        fieldName3, fieldDecoder3,
+                        fieldName4, fieldDecoder4,
+                        fieldName5, fieldDecoder5,
+                        fieldName6, fieldDecoder6,
+                        fieldName7, fieldDecoder7,
+                        fieldName8, fieldDecoder8,
+                        fieldName9, fieldDecoder9,
+                        fieldName10, fieldDecoder10}
+        }
+        return &generalStructDecoder{typ, fields, false}
+}
+
+type generalStructDecoder struct {
+        typ                   reflect2.Type
+        fields                map[string]*structFieldDecoder
+        disallowUnknownFields bool
+}
+
+func (decoder *generalStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.readObjectStart() {
+                return
+        }
+        if !iter.incrementDepth() {
+                return
+        }
+        var c byte
+        for c = ','; c == ','; c = iter.nextToken() {
+                decoder.decodeOneField(ptr, iter)
+        }
+        if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
+                iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
+        }
+        if c != '}' {
+                iter.ReportError("struct Decode", `expect }, but found `+string([]byte{c}))
+        }
+        iter.decrementDepth()
+}
+
+func (decoder *generalStructDecoder) decodeOneField(ptr unsafe.Pointer, iter *Iterator) {
+        var field string
+        var fieldDecoder *structFieldDecoder
+        if iter.cfg.objectFieldMustBeSimpleString {
+                fieldBytes := iter.ReadStringAsSlice()
+                field = *(*string)(unsafe.Pointer(&fieldBytes))
+                fieldDecoder = decoder.fields[field]
+                if fieldDecoder == nil && !iter.cfg.caseSensitive {
+                        fieldDecoder = decoder.fields[strings.ToLower(field)]
+                }
+        } else {
+                field = iter.ReadString()
+                fieldDecoder = decoder.fields[field]
+                if fieldDecoder == nil && !iter.cfg.caseSensitive {
+                        fieldDecoder = decoder.fields[strings.ToLower(field)]
+                }
+        }
+        if fieldDecoder == nil {
+                if decoder.disallowUnknownFields {
+                        msg := "found unknown field: " + field
+                        iter.ReportError("ReadObject", msg)
+                }
+                c := iter.nextToken()
+                if c != ':' {
+                        iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
+                }
+                iter.Skip()
+                return
+        }
+        c := iter.nextToken()
+        if c != ':' {
+                iter.ReportError("ReadObject", "expect : after object field, but found "+string([]byte{c}))
+        }
+        fieldDecoder.Decode(ptr, iter)
+}
+
+type skipObjectDecoder struct {
+        typ reflect2.Type
+}
+
+func (decoder *skipObjectDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        valueType := iter.WhatIsNext()
+        if valueType != ObjectValue && valueType != NilValue {
+                iter.ReportError("skipObjectDecoder", "expect object or null")
+                return
+        }
+        iter.Skip()
+}
+
+type oneFieldStructDecoder struct {
+        typ          reflect2.Type
+        fieldHash    int64
+        fieldDecoder *structFieldDecoder
+}
+
+func (decoder *oneFieldStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.readObjectStart() {
+                return
+        }
+        if !iter.incrementDepth() {
+                return
+        }
+        for {
+                if iter.readFieldHash() == decoder.fieldHash {
+                        decoder.fieldDecoder.Decode(ptr, iter)
+                } else {
+                        iter.Skip()
+                }
+                if iter.isObjectEnd() {
+                        break
+                }
+        }
+        if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
+                iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
+        }
+        iter.decrementDepth()
+}
+
+type twoFieldsStructDecoder struct {
+        typ           reflect2.Type
+        fieldHash1    int64
+        fieldDecoder1 *structFieldDecoder
+        fieldHash2    int64
+        fieldDecoder2 *structFieldDecoder
+}
+
+func (decoder *twoFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.readObjectStart() {
+                return
+        }
+        if !iter.incrementDepth() {
+                return
+        }
+        for {
+                switch iter.readFieldHash() {
+                case decoder.fieldHash1:
+                        decoder.fieldDecoder1.Decode(ptr, iter)
+                case decoder.fieldHash2:
+                        decoder.fieldDecoder2.Decode(ptr, iter)
+                default:
+                        iter.Skip()
+                }
+                if iter.isObjectEnd() {
+                        break
+                }
+        }
+        if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
+                iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
+        }
+        iter.decrementDepth()
+}
+
+type threeFieldsStructDecoder struct {
+        typ           reflect2.Type
+        fieldHash1    int64
+        fieldDecoder1 *structFieldDecoder
+        fieldHash2    int64
+        fieldDecoder2 *structFieldDecoder
+        fieldHash3    int64
+        fieldDecoder3 *structFieldDecoder
+}
+
+func (decoder *threeFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.readObjectStart() {
+                return
+        }
+        if !iter.incrementDepth() {
+                return
+        }
+        for {
+                switch iter.readFieldHash() {
+                case decoder.fieldHash1:
+                        decoder.fieldDecoder1.Decode(ptr, iter)
+                case decoder.fieldHash2:
+                        decoder.fieldDecoder2.Decode(ptr, iter)
+                case decoder.fieldHash3:
+                        decoder.fieldDecoder3.Decode(ptr, iter)
+                default:
+                        iter.Skip()
+                }
+                if iter.isObjectEnd() {
+                        break
+                }
+        }
+        if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
+                iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
+        }
+        iter.decrementDepth()
+}
+
+type fourFieldsStructDecoder struct {
+        typ           reflect2.Type
+        fieldHash1    int64
+        fieldDecoder1 *structFieldDecoder
+        fieldHash2    int64
+        fieldDecoder2 *structFieldDecoder
+        fieldHash3    int64
+        fieldDecoder3 *structFieldDecoder
+        fieldHash4    int64
+        fieldDecoder4 *structFieldDecoder
+}
+
+func (decoder *fourFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.readObjectStart() {
+                return
+        }
+        if !iter.incrementDepth() {
+                return
+        }
+        for {
+                switch iter.readFieldHash() {
+                case decoder.fieldHash1:
+                        decoder.fieldDecoder1.Decode(ptr, iter)
+                case decoder.fieldHash2:
+                        decoder.fieldDecoder2.Decode(ptr, iter)
+                case decoder.fieldHash3:
+                        decoder.fieldDecoder3.Decode(ptr, iter)
+                case decoder.fieldHash4:
+                        decoder.fieldDecoder4.Decode(ptr, iter)
+                default:
+                        iter.Skip()
+                }
+                if iter.isObjectEnd() {
+                        break
+                }
+        }
+        if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
+                iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
+        }
+        iter.decrementDepth()
+}
+
+type fiveFieldsStructDecoder struct {
+        typ           reflect2.Type
+        fieldHash1    int64
+        fieldDecoder1 *structFieldDecoder
+        fieldHash2    int64
+        fieldDecoder2 *structFieldDecoder
+        fieldHash3    int64
+        fieldDecoder3 *structFieldDecoder
+        fieldHash4    int64
+        fieldDecoder4 *structFieldDecoder
+        fieldHash5    int64
+        fieldDecoder5 *structFieldDecoder
+}
+
+func (decoder *fiveFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.readObjectStart() {
+                return
+        }
+        if !iter.incrementDepth() {
+                return
+        }
+        for {
+                switch iter.readFieldHash() {
+                case decoder.fieldHash1:
+                        decoder.fieldDecoder1.Decode(ptr, iter)
+                case decoder.fieldHash2:
+                        decoder.fieldDecoder2.Decode(ptr, iter)
+                case decoder.fieldHash3:
+                        decoder.fieldDecoder3.Decode(ptr, iter)
+                case decoder.fieldHash4:
+                        decoder.fieldDecoder4.Decode(ptr, iter)
+                case decoder.fieldHash5:
+                        decoder.fieldDecoder5.Decode(ptr, iter)
+                default:
+                        iter.Skip()
+                }
+                if iter.isObjectEnd() {
+                        break
+                }
+        }
+        if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
+                iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
+        }
+        iter.decrementDepth()
+}
+
+type sixFieldsStructDecoder struct {
+        typ           reflect2.Type
+        fieldHash1    int64
+        fieldDecoder1 *structFieldDecoder
+        fieldHash2    int64
+        fieldDecoder2 *structFieldDecoder
+        fieldHash3    int64
+        fieldDecoder3 *structFieldDecoder
+        fieldHash4    int64
+        fieldDecoder4 *structFieldDecoder
+        fieldHash5    int64
+        fieldDecoder5 *structFieldDecoder
+        fieldHash6    int64
+        fieldDecoder6 *structFieldDecoder
+}
+
+func (decoder *sixFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.readObjectStart() {
+                return
+        }
+        if !iter.incrementDepth() {
+                return
+        }
+        for {
+                switch iter.readFieldHash() {
+                case decoder.fieldHash1:
+                        decoder.fieldDecoder1.Decode(ptr, iter)
+                case decoder.fieldHash2:
+                        decoder.fieldDecoder2.Decode(ptr, iter)
+                case decoder.fieldHash3:
+                        decoder.fieldDecoder3.Decode(ptr, iter)
+                case decoder.fieldHash4:
+                        decoder.fieldDecoder4.Decode(ptr, iter)
+                case decoder.fieldHash5:
+                        decoder.fieldDecoder5.Decode(ptr, iter)
+                case decoder.fieldHash6:
+                        decoder.fieldDecoder6.Decode(ptr, iter)
+                default:
+                        iter.Skip()
+                }
+                if iter.isObjectEnd() {
+                        break
+                }
+        }
+        if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
+                iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
+        }
+        iter.decrementDepth()
+}
+
+type sevenFieldsStructDecoder struct {
+        typ           reflect2.Type
+        fieldHash1    int64
+        fieldDecoder1 *structFieldDecoder
+        fieldHash2    int64
+        fieldDecoder2 *structFieldDecoder
+        fieldHash3    int64
+        fieldDecoder3 *structFieldDecoder
+        fieldHash4    int64
+        fieldDecoder4 *structFieldDecoder
+        fieldHash5    int64
+        fieldDecoder5 *structFieldDecoder
+        fieldHash6    int64
+        fieldDecoder6 *structFieldDecoder
+        fieldHash7    int64
+        fieldDecoder7 *structFieldDecoder
+}
+
+func (decoder *sevenFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.readObjectStart() {
+                return
+        }
+        if !iter.incrementDepth() {
+                return
+        }
+        for {
+                switch iter.readFieldHash() {
+                case decoder.fieldHash1:
+                        decoder.fieldDecoder1.Decode(ptr, iter)
+                case decoder.fieldHash2:
+                        decoder.fieldDecoder2.Decode(ptr, iter)
+                case decoder.fieldHash3:
+                        decoder.fieldDecoder3.Decode(ptr, iter)
+                case decoder.fieldHash4:
+                        decoder.fieldDecoder4.Decode(ptr, iter)
+                case decoder.fieldHash5:
+                        decoder.fieldDecoder5.Decode(ptr, iter)
+                case decoder.fieldHash6:
+                        decoder.fieldDecoder6.Decode(ptr, iter)
+                case decoder.fieldHash7:
+                        decoder.fieldDecoder7.Decode(ptr, iter)
+                default:
+                        iter.Skip()
+                }
+                if iter.isObjectEnd() {
+                        break
+                }
+        }
+        if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
+                iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
+        }
+        iter.decrementDepth()
+}
+
+type eightFieldsStructDecoder struct {
+        typ           reflect2.Type
+        fieldHash1    int64
+        fieldDecoder1 *structFieldDecoder
+        fieldHash2    int64
+        fieldDecoder2 *structFieldDecoder
+        fieldHash3    int64
+        fieldDecoder3 *structFieldDecoder
+        fieldHash4    int64
+        fieldDecoder4 *structFieldDecoder
+        fieldHash5    int64
+        fieldDecoder5 *structFieldDecoder
+        fieldHash6    int64
+        fieldDecoder6 *structFieldDecoder
+        fieldHash7    int64
+        fieldDecoder7 *structFieldDecoder
+        fieldHash8    int64
+        fieldDecoder8 *structFieldDecoder
+}
+
+func (decoder *eightFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.readObjectStart() {
+                return
+        }
+        if !iter.incrementDepth() {
+                return
+        }
+        for {
+                switch iter.readFieldHash() {
+                case decoder.fieldHash1:
+                        decoder.fieldDecoder1.Decode(ptr, iter)
+                case decoder.fieldHash2:
+                        decoder.fieldDecoder2.Decode(ptr, iter)
+                case decoder.fieldHash3:
+                        decoder.fieldDecoder3.Decode(ptr, iter)
+                case decoder.fieldHash4:
+                        decoder.fieldDecoder4.Decode(ptr, iter)
+                case decoder.fieldHash5:
+                        decoder.fieldDecoder5.Decode(ptr, iter)
+                case decoder.fieldHash6:
+                        decoder.fieldDecoder6.Decode(ptr, iter)
+                case decoder.fieldHash7:
+                        decoder.fieldDecoder7.Decode(ptr, iter)
+                case decoder.fieldHash8:
+                        decoder.fieldDecoder8.Decode(ptr, iter)
+                default:
+                        iter.Skip()
+                }
+                if iter.isObjectEnd() {
+                        break
+                }
+        }
+        if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
+                iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
+        }
+        iter.decrementDepth()
+}
+
+type nineFieldsStructDecoder struct {
+        typ           reflect2.Type
+        fieldHash1    int64
+        fieldDecoder1 *structFieldDecoder
+        fieldHash2    int64
+        fieldDecoder2 *structFieldDecoder
+        fieldHash3    int64
+        fieldDecoder3 *structFieldDecoder
+        fieldHash4    int64
+        fieldDecoder4 *structFieldDecoder
+        fieldHash5    int64
+        fieldDecoder5 *structFieldDecoder
+        fieldHash6    int64
+        fieldDecoder6 *structFieldDecoder
+        fieldHash7    int64
+        fieldDecoder7 *structFieldDecoder
+        fieldHash8    int64
+        fieldDecoder8 *structFieldDecoder
+        fieldHash9    int64
+        fieldDecoder9 *structFieldDecoder
+}
+
+func (decoder *nineFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.readObjectStart() {
+                return
+        }
+        if !iter.incrementDepth() {
+                return
+        }
+        for {
+                switch iter.readFieldHash() {
+                case decoder.fieldHash1:
+                        decoder.fieldDecoder1.Decode(ptr, iter)
+                case decoder.fieldHash2:
+                        decoder.fieldDecoder2.Decode(ptr, iter)
+                case decoder.fieldHash3:
+                        decoder.fieldDecoder3.Decode(ptr, iter)
+                case decoder.fieldHash4:
+                        decoder.fieldDecoder4.Decode(ptr, iter)
+                case decoder.fieldHash5:
+                        decoder.fieldDecoder5.Decode(ptr, iter)
+                case decoder.fieldHash6:
+                        decoder.fieldDecoder6.Decode(ptr, iter)
+                case decoder.fieldHash7:
+                        decoder.fieldDecoder7.Decode(ptr, iter)
+                case decoder.fieldHash8:
+                        decoder.fieldDecoder8.Decode(ptr, iter)
+                case decoder.fieldHash9:
+                        decoder.fieldDecoder9.Decode(ptr, iter)
+                default:
+                        iter.Skip()
+                }
+                if iter.isObjectEnd() {
+                        break
+                }
+        }
+        if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
+                iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
+        }
+        iter.decrementDepth()
+}
+
+type tenFieldsStructDecoder struct {
+        typ            reflect2.Type
+        fieldHash1     int64
+        fieldDecoder1  *structFieldDecoder
+        fieldHash2     int64
+        fieldDecoder2  *structFieldDecoder
+        fieldHash3     int64
+        fieldDecoder3  *structFieldDecoder
+        fieldHash4     int64
+        fieldDecoder4  *structFieldDecoder
+        fieldHash5     int64
+        fieldDecoder5  *structFieldDecoder
+        fieldHash6     int64
+        fieldDecoder6  *structFieldDecoder
+        fieldHash7     int64
+        fieldDecoder7  *structFieldDecoder
+        fieldHash8     int64
+        fieldDecoder8  *structFieldDecoder
+        fieldHash9     int64
+        fieldDecoder9  *structFieldDecoder
+        fieldHash10    int64
+        fieldDecoder10 *structFieldDecoder
+}
+
+func (decoder *tenFieldsStructDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if !iter.readObjectStart() {
+                return
+        }
+        if !iter.incrementDepth() {
+                return
+        }
+        for {
+                switch iter.readFieldHash() {
+                case decoder.fieldHash1:
+                        decoder.fieldDecoder1.Decode(ptr, iter)
+                case decoder.fieldHash2:
+                        decoder.fieldDecoder2.Decode(ptr, iter)
+                case decoder.fieldHash3:
+                        decoder.fieldDecoder3.Decode(ptr, iter)
+                case decoder.fieldHash4:
+                        decoder.fieldDecoder4.Decode(ptr, iter)
+                case decoder.fieldHash5:
+                        decoder.fieldDecoder5.Decode(ptr, iter)
+                case decoder.fieldHash6:
+                        decoder.fieldDecoder6.Decode(ptr, iter)
+                case decoder.fieldHash7:
+                        decoder.fieldDecoder7.Decode(ptr, iter)
+                case decoder.fieldHash8:
+                        decoder.fieldDecoder8.Decode(ptr, iter)
+                case decoder.fieldHash9:
+                        decoder.fieldDecoder9.Decode(ptr, iter)
+                case decoder.fieldHash10:
+                        decoder.fieldDecoder10.Decode(ptr, iter)
+                default:
+                        iter.Skip()
+                }
+                if iter.isObjectEnd() {
+                        break
+                }
+        }
+        if iter.Error != nil && iter.Error != io.EOF && len(decoder.typ.Type1().Name()) != 0 {
+                iter.Error = fmt.Errorf("%v.%s", decoder.typ, iter.Error.Error())
+        }
+        iter.decrementDepth()
+}
+
+type structFieldDecoder struct {
+        field        reflect2.StructField
+        fieldDecoder ValDecoder
+}
+
+func (decoder *structFieldDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        fieldPtr := decoder.field.UnsafeGet(ptr)
+        decoder.fieldDecoder.Decode(fieldPtr, iter)
+        if iter.Error != nil && iter.Error != io.EOF {
+                iter.Error = fmt.Errorf("%s: %s", decoder.field.Name(), iter.Error.Error())
+        }
+}
+
+type stringModeStringDecoder struct {
+        elemDecoder ValDecoder
+        cfg         *frozenConfig
+}
+
+func (decoder *stringModeStringDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        decoder.elemDecoder.Decode(ptr, iter)
+        str := *((*string)(ptr))
+        tempIter := decoder.cfg.BorrowIterator([]byte(str))
+        defer decoder.cfg.ReturnIterator(tempIter)
+        *((*string)(ptr)) = tempIter.ReadString()
+}
+
+type stringModeNumberDecoder struct {
+        elemDecoder ValDecoder
+}
+
+func (decoder *stringModeNumberDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        if iter.WhatIsNext() == NilValue {
+                decoder.elemDecoder.Decode(ptr, iter)
+                return
+        }
+
+        c := iter.nextToken()
+        if c != '"' {
+                iter.ReportError("stringModeNumberDecoder", `expect ", but found `+string([]byte{c}))
+                return
+        }
+        decoder.elemDecoder.Decode(ptr, iter)
+        if iter.Error != nil {
+                return
+        }
+        c = iter.readByte()
+        if c != '"' {
+                iter.ReportError("stringModeNumberDecoder", `expect ", but found `+string([]byte{c}))
+                return
+        }
+}
diff --git a/vendor/github.com/json-iterator/go/reflect_struct_encoder.go b/vendor/github.com/json-iterator/go/reflect_struct_encoder.go
new file mode 100644
index 0000000..152e3ef
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/reflect_struct_encoder.go
@@ -0,0 +1,211 @@
+package jsoniter
+
+import (
+        "fmt"
+        "github.com/modern-go/reflect2"
+        "io"
+        "reflect"
+        "unsafe"
+)
+
+func encoderOfStruct(ctx *ctx, typ reflect2.Type) ValEncoder {
+        type bindingTo struct {
+                binding *Binding
+                toName  string
+                ignored bool
+        }
+        orderedBindings := []*bindingTo{}
+        structDescriptor := describeStruct(ctx, typ)
+        for _, binding := range structDescriptor.Fields {
+                for _, toName := range binding.ToNames {
+                        new := &bindingTo{
+                                binding: binding,
+                                toName:  toName,
+                        }
+                        for _, old := range orderedBindings {
+                                if old.toName != toName {
+                                        continue
+                                }
+                                old.ignored, new.ignored = resolveConflictBinding(ctx.frozenConfig, old.binding, new.binding)
+                        }
+                        orderedBindings = append(orderedBindings, new)
+                }
+        }
+        if len(orderedBindings) == 0 {
+                return &emptyStructEncoder{}
+        }
+        finalOrderedFields := []structFieldTo{}
+        for _, bindingTo := range orderedBindings {
+                if !bindingTo.ignored {
+                        finalOrderedFields = append(finalOrderedFields, structFieldTo{
+                                encoder: bindingTo.binding.Encoder.(*structFieldEncoder),
+                                toName:  bindingTo.toName,
+                        })
+                }
+        }
+        return &structEncoder{typ, finalOrderedFields}
+}
+
+func createCheckIsEmpty(ctx *ctx, typ reflect2.Type) checkIsEmpty {
+        encoder := createEncoderOfNative(ctx, typ)
+        if encoder != nil {
+                return encoder
+        }
+        kind := typ.Kind()
+        switch kind {
+        case reflect.Interface:
+                return &dynamicEncoder{typ}
+        case reflect.Struct:
+                return &structEncoder{typ: typ}
+        case reflect.Array:
+                return &arrayEncoder{}
+        case reflect.Slice:
+                return &sliceEncoder{}
+        case reflect.Map:
+                return encoderOfMap(ctx, typ)
+        case reflect.Ptr:
+                return &OptionalEncoder{}
+        default:
+                return &lazyErrorEncoder{err: fmt.Errorf("unsupported type: %v", typ)}
+        }
+}
+
+func resolveConflictBinding(cfg *frozenConfig, old, new *Binding) (ignoreOld, ignoreNew bool) {
+        newTagged := new.Field.Tag().Get(cfg.getTagKey()) != ""
+        oldTagged := old.Field.Tag().Get(cfg.getTagKey()) != ""
+        if newTagged {
+                if oldTagged {
+                        if len(old.levels) > len(new.levels) {
+                                return true, false
+                        } else if len(new.levels) > len(old.levels) {
+                                return false, true
+                        } else {
+                                return true, true
+                        }
+                } else {
+                        return true, false
+                }
+        } else {
+                if oldTagged {
+                        return true, false
+                }
+                if len(old.levels) > len(new.levels) {
+                        return true, false
+                } else if len(new.levels) > len(old.levels) {
+                        return false, true
+                } else {
+                        return true, true
+                }
+        }
+}
+
+type structFieldEncoder struct {
+        field        reflect2.StructField
+        fieldEncoder ValEncoder
+        omitempty    bool
+}
+
+func (encoder *structFieldEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        fieldPtr := encoder.field.UnsafeGet(ptr)
+        encoder.fieldEncoder.Encode(fieldPtr, stream)
+        if stream.Error != nil && stream.Error != io.EOF {
+                stream.Error = fmt.Errorf("%s: %s", encoder.field.Name(), stream.Error.Error())
+        }
+}
+
+func (encoder *structFieldEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        fieldPtr := encoder.field.UnsafeGet(ptr)
+        return encoder.fieldEncoder.IsEmpty(fieldPtr)
+}
+
+func (encoder *structFieldEncoder) IsEmbeddedPtrNil(ptr unsafe.Pointer) bool {
+        isEmbeddedPtrNil, converted := encoder.fieldEncoder.(IsEmbeddedPtrNil)
+        if !converted {
+                return false
+        }
+        fieldPtr := encoder.field.UnsafeGet(ptr)
+        return isEmbeddedPtrNil.IsEmbeddedPtrNil(fieldPtr)
+}
+
+type IsEmbeddedPtrNil interface {
+        IsEmbeddedPtrNil(ptr unsafe.Pointer) bool
+}
+
+type structEncoder struct {
+        typ    reflect2.Type
+        fields []structFieldTo
+}
+
+type structFieldTo struct {
+        encoder *structFieldEncoder
+        toName  string
+}
+
+func (encoder *structEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteObjectStart()
+        isNotFirst := false
+        for _, field := range encoder.fields {
+                if field.encoder.omitempty && field.encoder.IsEmpty(ptr) {
+                        continue
+                }
+                if field.encoder.IsEmbeddedPtrNil(ptr) {
+                        continue
+                }
+                if isNotFirst {
+                        stream.WriteMore()
+                }
+                stream.WriteObjectField(field.toName)
+                field.encoder.Encode(ptr, stream)
+                isNotFirst = true
+        }
+        stream.WriteObjectEnd()
+        if stream.Error != nil && stream.Error != io.EOF {
+                stream.Error = fmt.Errorf("%v.%s", encoder.typ, stream.Error.Error())
+        }
+}
+
+func (encoder *structEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return false
+}
+
+type emptyStructEncoder struct {
+}
+
+func (encoder *emptyStructEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.WriteEmptyObject()
+}
+
+func (encoder *emptyStructEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return false
+}
+
+type stringModeNumberEncoder struct {
+        elemEncoder ValEncoder
+}
+
+func (encoder *stringModeNumberEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        stream.writeByte('"')
+        encoder.elemEncoder.Encode(ptr, stream)
+        stream.writeByte('"')
+}
+
+func (encoder *stringModeNumberEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return encoder.elemEncoder.IsEmpty(ptr)
+}
+
+type stringModeStringEncoder struct {
+        elemEncoder ValEncoder
+        cfg         *frozenConfig
+}
+
+func (encoder *stringModeStringEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        tempStream := encoder.cfg.BorrowStream(nil)
+        tempStream.Attachment = stream.Attachment
+        defer encoder.cfg.ReturnStream(tempStream)
+        encoder.elemEncoder.Encode(ptr, tempStream)
+        stream.WriteString(string(tempStream.Buffer()))
+}
+
+func (encoder *stringModeStringEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        return encoder.elemEncoder.IsEmpty(ptr)
+}
diff --git a/vendor/github.com/json-iterator/go/stream.go b/vendor/github.com/json-iterator/go/stream.go
new file mode 100644
index 0000000..23d8a3a
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/stream.go
@@ -0,0 +1,210 @@
+package jsoniter
+
+import (
+        "io"
+)
+
+// stream is a io.Writer like object, with JSON specific write functions.
+// Error is not returned as return value, but stored as Error member on this stream instance.
+type Stream struct {
+        cfg        *frozenConfig
+        out        io.Writer
+        buf        []byte
+        Error      error
+        indention  int
+        Attachment interface{} // open for customized encoder
+}
+
+// NewStream create new stream instance.
+// cfg can be jsoniter.ConfigDefault.
+// out can be nil if write to internal buffer.
+// bufSize is the initial size for the internal buffer in bytes.
+func NewStream(cfg API, out io.Writer, bufSize int) *Stream {
+        return &Stream{
+                cfg:       cfg.(*frozenConfig),
+                out:       out,
+                buf:       make([]byte, 0, bufSize),
+                Error:     nil,
+                indention: 0,
+        }
+}
+
+// Pool returns a pool can provide more stream with same configuration
+func (stream *Stream) Pool() StreamPool {
+        return stream.cfg
+}
+
+// Reset reuse this stream instance by assign a new writer
+func (stream *Stream) Reset(out io.Writer) {
+        stream.out = out
+        stream.buf = stream.buf[:0]
+}
+
+// Available returns how many bytes are unused in the buffer.
+func (stream *Stream) Available() int {
+        return cap(stream.buf) - len(stream.buf)
+}
+
+// Buffered returns the number of bytes that have been written into the current buffer.
+func (stream *Stream) Buffered() int {
+        return len(stream.buf)
+}
+
+// Buffer if writer is nil, use this method to take the result
+func (stream *Stream) Buffer() []byte {
+        return stream.buf
+}
+
+// SetBuffer allows to append to the internal buffer directly
+func (stream *Stream) SetBuffer(buf []byte) {
+        stream.buf = buf
+}
+
+// Write writes the contents of p into the buffer.
+// It returns the number of bytes written.
+// If nn < len(p), it also returns an error explaining
+// why the write is short.
+func (stream *Stream) Write(p []byte) (nn int, err error) {
+        stream.buf = append(stream.buf, p...)
+        if stream.out != nil {
+                nn, err = stream.out.Write(stream.buf)
+                stream.buf = stream.buf[nn:]
+                return
+        }
+        return len(p), nil
+}
+
+// WriteByte writes a single byte.
+func (stream *Stream) writeByte(c byte) {
+        stream.buf = append(stream.buf, c)
+}
+
+func (stream *Stream) writeTwoBytes(c1 byte, c2 byte) {
+        stream.buf = append(stream.buf, c1, c2)
+}
+
+func (stream *Stream) writeThreeBytes(c1 byte, c2 byte, c3 byte) {
+        stream.buf = append(stream.buf, c1, c2, c3)
+}
+
+func (stream *Stream) writeFourBytes(c1 byte, c2 byte, c3 byte, c4 byte) {
+        stream.buf = append(stream.buf, c1, c2, c3, c4)
+}
+
+func (stream *Stream) writeFiveBytes(c1 byte, c2 byte, c3 byte, c4 byte, c5 byte) {
+        stream.buf = append(stream.buf, c1, c2, c3, c4, c5)
+}
+
+// Flush writes any buffered data to the underlying io.Writer.
+func (stream *Stream) Flush() error {
+        if stream.out == nil {
+                return nil
+        }
+        if stream.Error != nil {
+                return stream.Error
+        }
+        _, err := stream.out.Write(stream.buf)
+        if err != nil {
+                if stream.Error == nil {
+                        stream.Error = err
+                }
+                return err
+        }
+        stream.buf = stream.buf[:0]
+        return nil
+}
+
+// WriteRaw write string out without quotes, just like []byte
+func (stream *Stream) WriteRaw(s string) {
+        stream.buf = append(stream.buf, s...)
+}
+
+// WriteNil write null to stream
+func (stream *Stream) WriteNil() {
+        stream.writeFourBytes('n', 'u', 'l', 'l')
+}
+
+// WriteTrue write true to stream
+func (stream *Stream) WriteTrue() {
+        stream.writeFourBytes('t', 'r', 'u', 'e')
+}
+
+// WriteFalse write false to stream
+func (stream *Stream) WriteFalse() {
+        stream.writeFiveBytes('f', 'a', 'l', 's', 'e')
+}
+
+// WriteBool write true or false into stream
+func (stream *Stream) WriteBool(val bool) {
+        if val {
+                stream.WriteTrue()
+        } else {
+                stream.WriteFalse()
+        }
+}
+
+// WriteObjectStart write { with possible indention
+func (stream *Stream) WriteObjectStart() {
+        stream.indention += stream.cfg.indentionStep
+        stream.writeByte('{')
+        stream.writeIndention(0)
+}
+
+// WriteObjectField write "field": with possible indention
+func (stream *Stream) WriteObjectField(field string) {
+        stream.WriteString(field)
+        if stream.indention > 0 {
+                stream.writeTwoBytes(':', ' ')
+        } else {
+                stream.writeByte(':')
+        }
+}
+
+// WriteObjectEnd write } with possible indention
+func (stream *Stream) WriteObjectEnd() {
+        stream.writeIndention(stream.cfg.indentionStep)
+        stream.indention -= stream.cfg.indentionStep
+        stream.writeByte('}')
+}
+
+// WriteEmptyObject write {}
+func (stream *Stream) WriteEmptyObject() {
+        stream.writeByte('{')
+        stream.writeByte('}')
+}
+
+// WriteMore write , with possible indention
+func (stream *Stream) WriteMore() {
+        stream.writeByte(',')
+        stream.writeIndention(0)
+}
+
+// WriteArrayStart write [ with possible indention
+func (stream *Stream) WriteArrayStart() {
+        stream.indention += stream.cfg.indentionStep
+        stream.writeByte('[')
+        stream.writeIndention(0)
+}
+
+// WriteEmptyArray write []
+func (stream *Stream) WriteEmptyArray() {
+        stream.writeTwoBytes('[', ']')
+}
+
+// WriteArrayEnd write ] with possible indention
+func (stream *Stream) WriteArrayEnd() {
+        stream.writeIndention(stream.cfg.indentionStep)
+        stream.indention -= stream.cfg.indentionStep
+        stream.writeByte(']')
+}
+
+func (stream *Stream) writeIndention(delta int) {
+        if stream.indention == 0 {
+                return
+        }
+        stream.writeByte('\n')
+        toWrite := stream.indention - delta
+        for i := 0; i < toWrite; i++ {
+                stream.buf = append(stream.buf, ' ')
+        }
+}
diff --git a/vendor/github.com/json-iterator/go/stream_float.go b/vendor/github.com/json-iterator/go/stream_float.go
new file mode 100644
index 0000000..826aa59
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/stream_float.go
@@ -0,0 +1,111 @@
+package jsoniter
+
+import (
+        "fmt"
+        "math"
+        "strconv"
+)
+
+var pow10 []uint64
+
+func init() {
+        pow10 = []uint64{1, 10, 100, 1000, 10000, 100000, 1000000}
+}
+
+// WriteFloat32 write float32 to stream
+func (stream *Stream) WriteFloat32(val float32) {
+        if math.IsInf(float64(val), 0) || math.IsNaN(float64(val)) {
+                stream.Error = fmt.Errorf("unsupported value: %f", val)
+                return
+        }
+        abs := math.Abs(float64(val))
+        fmt := byte('f')
+        // Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
+        if abs != 0 {
+                if float32(abs) < 1e-6 || float32(abs) >= 1e21 {
+                        fmt = 'e'
+                }
+        }
+        stream.buf = strconv.AppendFloat(stream.buf, float64(val), fmt, -1, 32)
+}
+
+// WriteFloat32Lossy write float32 to stream with ONLY 6 digits precision although much much faster
+func (stream *Stream) WriteFloat32Lossy(val float32) {
+        if math.IsInf(float64(val), 0) || math.IsNaN(float64(val)) {
+                stream.Error = fmt.Errorf("unsupported value: %f", val)
+                return
+        }
+        if val < 0 {
+                stream.writeByte('-')
+                val = -val
+        }
+        if val > 0x4ffffff {
+                stream.WriteFloat32(val)
+                return
+        }
+        precision := 6
+        exp := uint64(1000000) // 6
+        lval := uint64(float64(val)*float64(exp) + 0.5)
+        stream.WriteUint64(lval / exp)
+        fval := lval % exp
+        if fval == 0 {
+                return
+        }
+        stream.writeByte('.')
+        for p := precision - 1; p > 0 && fval < pow10[p]; p-- {
+                stream.writeByte('0')
+        }
+        stream.WriteUint64(fval)
+        for stream.buf[len(stream.buf)-1] == '0' {
+                stream.buf = stream.buf[:len(stream.buf)-1]
+        }
+}
+
+// WriteFloat64 write float64 to stream
+func (stream *Stream) WriteFloat64(val float64) {
+        if math.IsInf(val, 0) || math.IsNaN(val) {
+                stream.Error = fmt.Errorf("unsupported value: %f", val)
+                return
+        }
+        abs := math.Abs(val)
+        fmt := byte('f')
+        // Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
+        if abs != 0 {
+                if abs < 1e-6 || abs >= 1e21 {
+                        fmt = 'e'
+                }
+        }
+        stream.buf = strconv.AppendFloat(stream.buf, float64(val), fmt, -1, 64)
+}
+
+// WriteFloat64Lossy write float64 to stream with ONLY 6 digits precision although much much faster
+func (stream *Stream) WriteFloat64Lossy(val float64) {
+        if math.IsInf(val, 0) || math.IsNaN(val) {
+                stream.Error = fmt.Errorf("unsupported value: %f", val)
+                return
+        }
+        if val < 0 {
+                stream.writeByte('-')
+                val = -val
+        }
+        if val > 0x4ffffff {
+                stream.WriteFloat64(val)
+                return
+        }
+        precision := 6
+        exp := uint64(1000000) // 6
+        lval := uint64(val*float64(exp) + 0.5)
+        stream.WriteUint64(lval / exp)
+        fval := lval % exp
+        if fval == 0 {
+                return
+        }
+        stream.writeByte('.')
+        for p := precision - 1; p > 0 && fval < pow10[p]; p-- {
+                stream.writeByte('0')
+        }
+        stream.WriteUint64(fval)
+        for stream.buf[len(stream.buf)-1] == '0' {
+                stream.buf = stream.buf[:len(stream.buf)-1]
+        }
+}
diff --git a/vendor/github.com/json-iterator/go/stream_int.go b/vendor/github.com/json-iterator/go/stream_int.go
new file mode 100644
index 0000000..d1059ee
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/stream_int.go
@@ -0,0 +1,190 @@
+package jsoniter
+
+var digits []uint32
+
+func init() {
+        digits = make([]uint32, 1000)
+        for i := uint32(0); i < 1000; i++ {
+                digits[i] = (((i / 100) + '0') << 16) + ((((i / 10) % 10) + '0') << 8) + i%10 + '0'
+                if i < 10 {
+                        digits[i] += 2 << 24
+                } else if i < 100 {
+                        digits[i] += 1 << 24
+                }
+        }
+}
+
+func writeFirstBuf(space []byte, v uint32) []byte {
+        start := v >> 24
+        if start == 0 {
+                space = append(space, byte(v>>16), byte(v>>8))
+        } else if start == 1 {
+                space = append(space, byte(v>>8))
+        }
+        space = append(space, byte(v))
+        return space
+}
+
+func writeBuf(buf []byte, v uint32) []byte {
+        return append(buf, byte(v>>16), byte(v>>8), byte(v))
+}
+
+// WriteUint8 write uint8 to stream
+func (stream *Stream) WriteUint8(val uint8) {
+        stream.buf = writeFirstBuf(stream.buf, digits[val])
+}
+
+// WriteInt8 write int8 to stream
+func (stream *Stream) WriteInt8(nval int8) {
+        var val uint8
+        if nval < 0 {
+                val = uint8(-nval)
+                stream.buf = append(stream.buf, '-')
+        } else {
+                val = uint8(nval)
+        }
+        stream.buf = writeFirstBuf(stream.buf, digits[val])
+}
+
+// WriteUint16 write uint16 to stream
+func (stream *Stream) WriteUint16(val uint16) {
+        q1 := val / 1000
+        if q1 == 0 {
+                stream.buf = writeFirstBuf(stream.buf, digits[val])
+                return
+        }
+        r1 := val - q1*1000
+        stream.buf = writeFirstBuf(stream.buf, digits[q1])
+        stream.buf = writeBuf(stream.buf, digits[r1])
+        return
+}
+
+// WriteInt16 write int16 to stream
+func (stream *Stream) WriteInt16(nval int16) {
+        var val uint16
+        if nval < 0 {
+                val = uint16(-nval)
+                stream.buf = append(stream.buf, '-')
+        } else {
+                val = uint16(nval)
+        }
+        stream.WriteUint16(val)
+}
+
+// WriteUint32 write uint32 to stream
+func (stream *Stream) WriteUint32(val uint32) {
+        q1 := val / 1000
+        if q1 == 0 {
+                stream.buf = writeFirstBuf(stream.buf, digits[val])
+                return
+        }
+        r1 := val - q1*1000
+        q2 := q1 / 1000
+        if q2 == 0 {
+                stream.buf = writeFirstBuf(stream.buf, digits[q1])
+                stream.buf = writeBuf(stream.buf, digits[r1])
+                return
+        }
+        r2 := q1 - q2*1000
+        q3 := q2 / 1000
+        if q3 == 0 {
+                stream.buf = writeFirstBuf(stream.buf, digits[q2])
+        } else {
+                r3 := q2 - q3*1000
+                stream.buf = append(stream.buf, byte(q3+'0'))
+                stream.buf = writeBuf(stream.buf, digits[r3])
+        }
+        stream.buf = writeBuf(stream.buf, digits[r2])
+        stream.buf = writeBuf(stream.buf, digits[r1])
+}
+
+// WriteInt32 write int32 to stream
+func (stream *Stream) WriteInt32(nval int32) {
+        var val uint32
+        if nval < 0 {
+                val = uint32(-nval)
+                stream.buf = append(stream.buf, '-')
+        } else {
+                val = uint32(nval)
+        }
+        stream.WriteUint32(val)
+}
+
+// WriteUint64 write uint64 to stream
+func (stream *Stream) WriteUint64(val uint64) {
+        q1 := val / 1000
+        if q1 == 0 {
+                stream.buf = writeFirstBuf(stream.buf, digits[val])
+                return
+        }
+        r1 := val - q1*1000
+        q2 := q1 / 1000
+        if q2 == 0 {
+                stream.buf = writeFirstBuf(stream.buf, digits[q1])
+                stream.buf = writeBuf(stream.buf, digits[r1])
+                return
+        }
+        r2 := q1 - q2*1000
+        q3 := q2 / 1000
+        if q3 == 0 {
+                stream.buf = writeFirstBuf(stream.buf, digits[q2])
+                stream.buf = writeBuf(stream.buf, digits[r2])
+                stream.buf = writeBuf(stream.buf, digits[r1])
+                return
+        }
+        r3 := q2 - q3*1000
+        q4 := q3 / 1000
+        if q4 == 0 {
+                stream.buf = writeFirstBuf(stream.buf, digits[q3])
+                stream.buf = writeBuf(stream.buf, digits[r3])
+                stream.buf = writeBuf(stream.buf, digits[r2])
+                stream.buf = writeBuf(stream.buf, digits[r1])
+                return
+        }
+        r4 := q3 - q4*1000
+        q5 := q4 / 1000
+        if q5 == 0 {
+                stream.buf = writeFirstBuf(stream.buf, digits[q4])
+                stream.buf = writeBuf(stream.buf, digits[r4])
+                stream.buf = writeBuf(stream.buf, digits[r3])
+                stream.buf = writeBuf(stream.buf, digits[r2])
+                stream.buf = writeBuf(stream.buf, digits[r1])
+                return
+        }
+        r5 := q4 - q5*1000
+        q6 := q5 / 1000
+        if q6 == 0 {
+                stream.buf = writeFirstBuf(stream.buf, digits[q5])
+        } else {
+                stream.buf = writeFirstBuf(stream.buf, digits[q6])
+                r6 := q5 - q6*1000
+                stream.buf = writeBuf(stream.buf, digits[r6])
+        }
+        stream.buf = writeBuf(stream.buf, digits[r5])
+        stream.buf = writeBuf(stream.buf, digits[r4])
+        stream.buf = writeBuf(stream.buf, digits[r3])
+        stream.buf = writeBuf(stream.buf, digits[r2])
+        stream.buf = writeBuf(stream.buf, digits[r1])
+}
+
+// WriteInt64 write int64 to stream
+func (stream *Stream) WriteInt64(nval int64) {
+        var val uint64
+        if nval < 0 {
+                val = uint64(-nval)
+                stream.buf = append(stream.buf, '-')
+        } else {
+                val = uint64(nval)
+        }
+        stream.WriteUint64(val)
+}
+
+// WriteInt write int to stream
+func (stream *Stream) WriteInt(val int) {
+        stream.WriteInt64(int64(val))
+}
+
+// WriteUint write uint to stream
+func (stream *Stream) WriteUint(val uint) {
+        stream.WriteUint64(uint64(val))
+}
diff --git a/vendor/github.com/json-iterator/go/stream_str.go b/vendor/github.com/json-iterator/go/stream_str.go
new file mode 100644
index 0000000..54c2ba0
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/stream_str.go
@@ -0,0 +1,372 @@
+package jsoniter
+
+import (
+        "unicode/utf8"
+)
+
+// htmlSafeSet holds the value true if the ASCII character with the given
+// array position can be safely represented inside a JSON string, embedded
+// inside of HTML <script> tags, without any additional escaping.
+//
+// All values are true except for the ASCII control characters (0-31), the
+// double quote ("), the backslash character ("\"), HTML opening and closing
+// tags ("<" and ">"), and the ampersand ("&").
+var htmlSafeSet = [utf8.RuneSelf]bool{
+        ' ':      true,
+        '!':      true,
+        '"':      false,
+        '#':      true,
+        '$':      true,
+        '%':      true,
+        '&':      false,
+        '\'':     true,
+        '(':      true,
+        ')':      true,
+        '*':      true,
+        '+':      true,
+        ',':      true,
+        '-':      true,
+        '.':      true,
+        '/':      true,
+        '0':      true,
+        '1':      true,
+        '2':      true,
+        '3':      true,
+        '4':      true,
+        '5':      true,
+        '6':      true,
+        '7':      true,
+        '8':      true,
+        '9':      true,
+        ':':      true,
+        ';':      true,
+        '<':      false,
+        '=':      true,
+        '>':      false,
+        '?':      true,
+        '@':      true,
+        'A':      true,
+        'B':      true,
+        'C':      true,
+        'D':      true,
+        'E':      true,
+        'F':      true,
+        'G':      true,
+        'H':      true,
+        'I':      true,
+        'J':      true,
+        'K':      true,
+        'L':      true,
+        'M':      true,
+        'N':      true,
+        'O':      true,
+        'P':      true,
+        'Q':      true,
+        'R':      true,
+        'S':      true,
+        'T':      true,
+        'U':      true,
+        'V':      true,
+        'W':      true,
+        'X':      true,
+        'Y':      true,
+        'Z':      true,
+        '[':      true,
+        '\\':     false,
+        ']':      true,
+        '^':      true,
+        '_':      true,
+        '`':      true,
+        'a':      true,
+        'b':      true,
+        'c':      true,
+        'd':      true,
+        'e':      true,
+        'f':      true,
+        'g':      true,
+        'h':      true,
+        'i':      true,
+        'j':      true,
+        'k':      true,
+        'l':      true,
+        'm':      true,
+        'n':      true,
+        'o':      true,
+        'p':      true,
+        'q':      true,
+        'r':      true,
+        's':      true,
+        't':      true,
+        'u':      true,
+        'v':      true,
+        'w':      true,
+        'x':      true,
+        'y':      true,
+        'z':      true,
+        '{':      true,
+        '|':      true,
+        '}':      true,
+        '~':      true,
+        '\u007f': true,
+}
+
+// safeSet holds the value true if the ASCII character with the given array
+// position can be represented inside a JSON string without any further
+// escaping.
+//
+// All values are true except for the ASCII control characters (0-31), the
+// double quote ("), and the backslash character ("\").
+var safeSet = [utf8.RuneSelf]bool{
+        ' ':      true,
+        '!':      true,
+        '"':      false,
+        '#':      true,
+        '$':      true,
+        '%':      true,
+        '&':      true,
+        '\'':     true,
+        '(':      true,
+        ')':      true,
+        '*':      true,
+        '+':      true,
+        ',':      true,
+        '-':      true,
+        '.':      true,
+        '/':      true,
+        '0':      true,
+        '1':      true,
+        '2':      true,
+        '3':      true,
+        '4':      true,
+        '5':      true,
+        '6':      true,
+        '7':      true,
+        '8':      true,
+        '9':      true,
+        ':':      true,
+        ';':      true,
+        '<':      true,
+        '=':      true,
+        '>':      true,
+        '?':      true,
+        '@':      true,
+        'A':      true,
+        'B':      true,
+        'C':      true,
+        'D':      true,
+        'E':      true,
+        'F':      true,
+        'G':      true,
+        'H':      true,
+        'I':      true,
+        'J':      true,
+        'K':      true,
+        'L':      true,
+        'M':      true,
+        'N':      true,
+        'O':      true,
+        'P':      true,
+        'Q':      true,
+        'R':      true,
+        'S':      true,
+        'T':      true,
+        'U':      true,
+        'V':      true,
+        'W':      true,
+        'X':      true,
+        'Y':      true,
+        'Z':      true,
+        '[':      true,
+        '\\':     false,
+        ']':      true,
+        '^':      true,
+        '_':      true,
+        '`':      true,
+        'a':      true,
+        'b':      true,
+        'c':      true,
+        'd':      true,
+        'e':      true,
+        'f':      true,
+        'g':      true,
+        'h':      true,
+        'i':      true,
+        'j':      true,
+        'k':      true,
+        'l':      true,
+        'm':      true,
+        'n':      true,
+        'o':      true,
+        'p':      true,
+        'q':      true,
+        'r':      true,
+        's':      true,
+        't':      true,
+        'u':      true,
+        'v':      true,
+        'w':      true,
+        'x':      true,
+        'y':      true,
+        'z':      true,
+        '{':      true,
+        '|':      true,
+        '}':      true,
+        '~':      true,
+        '\u007f': true,
+}
+
+var hex = "0123456789abcdef"
+
+// WriteStringWithHTMLEscaped write string to stream with html special characters escaped
+func (stream *Stream) WriteStringWithHTMLEscaped(s string) {
+        valLen := len(s)
+        stream.buf = append(stream.buf, '"')
+        // write string, the fast path, without utf8 and escape support
+        i := 0
+        for ; i < valLen; i++ {
+                c := s[i]
+                if c < utf8.RuneSelf && htmlSafeSet[c] {
+                        stream.buf = append(stream.buf, c)
+                } else {
+                        break
+                }
+        }
+        if i == valLen {
+                stream.buf = append(stream.buf, '"')
+                return
+        }
+        writeStringSlowPathWithHTMLEscaped(stream, i, s, valLen)
+}
+
+func writeStringSlowPathWithHTMLEscaped(stream *Stream, i int, s string, valLen int) {
+        start := i
+        // for the remaining parts, we process them char by char
+        for i < valLen {
+                if b := s[i]; b < utf8.RuneSelf {
+                        if htmlSafeSet[b] {
+                                i++
+                                continue
+                        }
+                        if start < i {
+                                stream.WriteRaw(s[start:i])
+                        }
+                        switch b {
+                        case '\\', '"':
+                                stream.writeTwoBytes('\\', b)
+                        case '\n':
+                                stream.writeTwoBytes('\\', 'n')
+                        case '\r':
+                                stream.writeTwoBytes('\\', 'r')
+                        case '\t':
+                                stream.writeTwoBytes('\\', 't')
+                        default:
+                                // This encodes bytes < 0x20 except for \t, \n and \r.
+                                // If escapeHTML is set, it also escapes <, >, and &
+                                // because they can lead to security holes when
+                                // user-controlled strings are rendered into JSON
+                                // and served to some browsers.
+                                stream.WriteRaw(`\u00`)
+                                stream.writeTwoBytes(hex[b>>4], hex[b&0xF])
+                        }
+                        i++
+                        start = i
+                        continue
+                }
+                c, size := utf8.DecodeRuneInString(s[i:])
+                if c == utf8.RuneError && size == 1 {
+                        if start < i {
+                                stream.WriteRaw(s[start:i])
+                        }
+                        stream.WriteRaw(`\ufffd`)
+                        i++
+                        start = i
+                        continue
+                }
+                // U+2028 is LINE SEPARATOR.
+                // U+2029 is PARAGRAPH SEPARATOR.
+                // They are both technically valid characters in JSON strings,
+                // but don't work in JSONP, which has to be evaluated as JavaScript,
+                // and can lead to security holes there. It is valid JSON to
+                // escape them, so we do so unconditionally.
+                // See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
+                if c == '\u2028' || c == '\u2029' {
+                        if start < i {
+                                stream.WriteRaw(s[start:i])
+                        }
+                        stream.WriteRaw(`\u202`)
+                        stream.writeByte(hex[c&0xF])
+                        i += size
+                        start = i
+                        continue
+                }
+                i += size
+        }
+        if start < len(s) {
+                stream.WriteRaw(s[start:])
+        }
+        stream.writeByte('"')
+}
+
+// WriteString write string to stream without html escape
+func (stream *Stream) WriteString(s string) {
+        valLen := len(s)
+        stream.buf = append(stream.buf, '"')
+        // write string, the fast path, without utf8 and escape support
+        i := 0
+        for ; i < valLen; i++ {
+                c := s[i]
+                if c > 31 && c != '"' && c != '\\' {
+                        stream.buf = append(stream.buf, c)
+                } else {
+                        break
+                }
+        }
+        if i == valLen {
+                stream.buf = append(stream.buf, '"')
+                return
+        }
+        writeStringSlowPath(stream, i, s, valLen)
+}
+
+func writeStringSlowPath(stream *Stream, i int, s string, valLen int) {
+        start := i
+        // for the remaining parts, we process them char by char
+        for i < valLen {
+                if b := s[i]; b < utf8.RuneSelf {
+                        if safeSet[b] {
+                                i++
+                                continue
+                        }
+                        if start < i {
+                                stream.WriteRaw(s[start:i])
+                        }
+                        switch b {
+                        case '\\', '"':
+                                stream.writeTwoBytes('\\', b)
+                        case '\n':
+                                stream.writeTwoBytes('\\', 'n')
+                        case '\r':
+                                stream.writeTwoBytes('\\', 'r')
+                        case '\t':
+                                stream.writeTwoBytes('\\', 't')
+                        default:
+                                // This encodes bytes < 0x20 except for \t, \n and \r.
+                                // If escapeHTML is set, it also escapes <, >, and &
+                                // because they can lead to security holes when
+                                // user-controlled strings are rendered into JSON
+                                // and served to some browsers.
+                                stream.WriteRaw(`\u00`)
+                                stream.writeTwoBytes(hex[b>>4], hex[b&0xF])
+                        }
+                        i++
+                        start = i
+                        continue
+                }
+                i++
+                continue
+        }
+        if start < len(s) {
+                stream.WriteRaw(s[start:])
+        }
+        stream.writeByte('"')
+}
diff --git a/vendor/github.com/json-iterator/go/test.sh b/vendor/github.com/json-iterator/go/test.sh
new file mode 100644
index 0000000..f4e7c0b
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/test.sh
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+set -e
+echo "" > coverage.txt
+
+for d in $(go list ./... | grep -v vendor); do
+    go test -coverprofile=profile.out -coverpkg=github.com/json-iterator/go $d
+    if [ -f profile.out ]; then
+        cat profile.out >> coverage.txt
+        rm profile.out
+    fi
+done
diff --git a/vendor/github.com/klauspost/compress/LICENSE b/vendor/github.com/klauspost/compress/LICENSE
new file mode 100644
index 0000000..87d5574
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/LICENSE
@@ -0,0 +1,304 @@
+Copyright (c) 2012 The Go Authors. All rights reserved.
+Copyright (c) 2019 Klaus Post. 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.
+
+------------------
+
+Files: gzhttp/*
+
+                                 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 2016-2017 The New York Times Company
+
+   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.
+
+------------------
+
+Files: s2/cmd/internal/readahead/*
+
+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.
+
+---------------------
+Files: snappy/*
+Files: internal/snapref/*
+
+Copyright (c) 2011 The Snappy-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.
+
+-----------------
+
+Files: s2/cmd/internal/filepathx/*
+
+Copyright 2016 The filepathx Authors
+
+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.
diff --git a/vendor/github.com/klauspost/compress/s2/.gitignore b/vendor/github.com/klauspost/compress/s2/.gitignore
new file mode 100644
index 0000000..3a89c6e
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/.gitignore
@@ -0,0 +1,15 @@
+testdata/bench
+
+# These explicitly listed benchmark data files are for an obsolete version of
+# snappy_test.go.
+testdata/alice29.txt
+testdata/asyoulik.txt
+testdata/fireworks.jpeg
+testdata/geo.protodata
+testdata/html
+testdata/html_x_4
+testdata/kppkn.gtb
+testdata/lcet10.txt
+testdata/paper-100k.pdf
+testdata/plrabn12.txt
+testdata/urls.10K
diff --git a/vendor/github.com/klauspost/compress/s2/LICENSE b/vendor/github.com/klauspost/compress/s2/LICENSE
new file mode 100644
index 0000000..1d2d645
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/LICENSE
@@ -0,0 +1,28 @@
+Copyright (c) 2011 The Snappy-Go Authors. All rights reserved.
+Copyright (c) 2019 Klaus Post. 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.
diff --git a/vendor/github.com/klauspost/compress/s2/README.md b/vendor/github.com/klauspost/compress/s2/README.md
new file mode 100644
index 0000000..8284bb0
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/README.md
@@ -0,0 +1,1120 @@
+# S2 Compression
+
+S2 is an extension of [Snappy](https://github.com/google/snappy).
+
+S2 is aimed for high throughput, which is why it features concurrent compression for bigger payloads.
+
+Decoding is compatible with Snappy compressed content, but content compressed with S2 cannot be decompressed by Snappy.
+This means that S2 can seamlessly replace Snappy without converting compressed content.
+
+S2 can produce Snappy compatible output, faster and better than Snappy.
+If you want full benefit of the changes you should use s2 without Snappy compatibility. 
+
+S2 is designed to have high throughput on content that cannot be compressed.
+This is important, so you don't have to worry about spending CPU cycles on already compressed data. 
+
+## Benefits over Snappy
+
+* Better compression
+* Adjustable compression (3 levels) 
+* Concurrent stream compression
+* Faster decompression, even for Snappy compatible content
+* Concurrent Snappy/S2 stream decompression
+* Skip forward in compressed stream
+* Random seeking with indexes
+* Compatible with reading Snappy compressed content
+* Smaller block size overhead on incompressible blocks
+* Block concatenation
+* Block Dictionary support
+* Uncompressed stream mode
+* Automatic stream size padding
+* Snappy compatible block compression
+
+## Drawbacks over Snappy
+
+* Not optimized for 32 bit systems
+* Streams use slightly more memory due to larger blocks and concurrency (configurable)
+
+# Usage
+
+Installation: `go get -u github.com/klauspost/compress/s2`
+
+Full package documentation:
+ 
+[![godoc][1]][2]
+
+[1]: https://godoc.org/github.com/klauspost/compress?status.svg
+[2]: https://godoc.org/github.com/klauspost/compress/s2
+
+## Compression
+
+```Go
+func EncodeStream(src io.Reader, dst io.Writer) error {
+    enc := s2.NewWriter(dst)
+    _, err := io.Copy(enc, src)
+    if err != nil {
+        enc.Close()
+        return err
+    }
+    // Blocks until compression is done.
+    return enc.Close() 
+}
+```
+
+You should always call `enc.Close()`, otherwise you will leak resources and your encode will be incomplete.
+
+For the best throughput, you should attempt to reuse the `Writer` using the `Reset()` method.
+
+The Writer in S2 is always buffered, therefore `NewBufferedWriter` in Snappy can be replaced with `NewWriter` in S2.
+It is possible to flush any buffered data using the `Flush()` method. 
+This will block until all data sent to the encoder has been written to the output.
+
+S2 also supports the `io.ReaderFrom` interface, which will consume all input from a reader.
+
+As a final method to compress data, if you have a single block of data you would like to have encoded as a stream,
+a slightly more efficient method is to use the `EncodeBuffer` method.
+This will take ownership of the buffer until the stream is closed.
+
+```Go
+func EncodeStream(src []byte, dst io.Writer) error {
+    enc := s2.NewWriter(dst)
+    // The encoder owns the buffer until Flush or Close is called.
+    err := enc.EncodeBuffer(buf)
+    if err != nil {
+        enc.Close()
+        return err
+    }
+    // Blocks until compression is done.
+    return enc.Close()
+}
+```
+
+Each call to `EncodeBuffer` will result in discrete blocks being created without buffering, 
+so it should only be used a single time per stream.
+If you need to write several blocks, you should use the regular io.Writer interface.
+
+
+## Decompression
+
+```Go
+func DecodeStream(src io.Reader, dst io.Writer) error {
+    dec := s2.NewReader(src)
+    _, err := io.Copy(dst, dec)
+    return err
+}
+```
+
+Similar to the Writer, a Reader can be reused using the `Reset` method.
+
+For the best possible throughput, there is a `EncodeBuffer(buf []byte)` function available.
+However, it requires that the provided buffer isn't used after it is handed over to S2 and until the stream is flushed or closed.  
+
+For smaller data blocks, there is also a non-streaming interface: `Encode()`, `EncodeBetter()` and `Decode()`.
+Do however note that these functions (similar to Snappy) does not provide validation of data, 
+so data corruption may be undetected. Stream encoding provides CRC checks of data.
+
+It is possible to efficiently skip forward in a compressed stream using the `Skip()` method. 
+For big skips the decompressor is able to skip blocks without decompressing them.
+
+## Single Blocks
+
+Similar to Snappy S2 offers single block compression. 
+Blocks do not offer the same flexibility and safety as streams,
+but may be preferable for very small payloads, less than 100K.
+
+Using a simple `dst := s2.Encode(nil, src)` will compress `src` and return the compressed result. 
+It is possible to provide a destination buffer. 
+If the buffer has a capacity of `s2.MaxEncodedLen(len(src))` it will be used. 
+If not a new will be allocated. 
+
+Alternatively `EncodeBetter`/`EncodeBest` can also be used for better, but slightly slower compression.
+
+Similarly to decompress a block you can use `dst, err := s2.Decode(nil, src)`. 
+Again an optional destination buffer can be supplied. 
+The `s2.DecodedLen(src)` can be used to get the minimum capacity needed. 
+If that is not satisfied a new buffer will be allocated.
+
+Block function always operate on a single goroutine since it should only be used for small payloads.
+
+# Commandline tools
+
+Some very simply commandline tools are provided; `s2c` for compression and `s2d` for decompression.
+
+Binaries can be downloaded on the [Releases Page](https://github.com/klauspost/compress/releases).
+
+Installing then requires Go to be installed. To install them, use:
+
+`go install github.com/klauspost/compress/s2/cmd/s2c@latest && go install github.com/klauspost/compress/s2/cmd/s2d@latest`
+
+To build binaries to the current folder use:
+
+`go build github.com/klauspost/compress/s2/cmd/s2c && go build github.com/klauspost/compress/s2/cmd/s2d`
+
+
+## s2c
+
+```
+Usage: s2c [options] file1 file2
+
+Compresses all files supplied as input separately.
+Output files are written as 'filename.ext.s2' or 'filename.ext.snappy'.
+By default output files will be overwritten.
+Use - as the only file name to read from stdin and write to stdout.
+
+Wildcards are accepted: testdir/*.txt will compress all files in testdir ending with .txt
+Directories can be wildcards as well. testdir/*/*.txt will match testdir/subdir/b.txt
+
+File names beginning with 'http://' and 'https://' will be downloaded and compressed.
+Only http response code 200 is accepted.
+
+Options:
+  -bench int
+        Run benchmark n times. No output will be written
+  -blocksize string
+        Max  block size. Examples: 64K, 256K, 1M, 4M. Must be power of two and <= 4MB (default "4M")
+  -c    Write all output to stdout. Multiple input files will be concatenated
+  -cpu int
+        Compress using this amount of threads (default 32)
+  -faster
+        Compress faster, but with a minor compression loss
+  -help
+        Display help
+  -index
+        Add seek index (default true)           
+  -o string
+        Write output to another file. Single input file only
+  -pad string
+        Pad size to a multiple of this value, Examples: 500, 64K, 256K, 1M, 4M, etc (default "1")
+  -q    Don't write any output to terminal, except errors
+  -rm
+        Delete source file(s) after successful compression
+  -safe
+        Do not overwrite output files
+  -slower
+        Compress more, but a lot slower
+  -snappy
+        Generate Snappy compatible output stream
+  -verify
+        Verify written files  
+
+```
+
+## s2d
+
+```
+Usage: s2d [options] file1 file2
+
+Decompresses all files supplied as input. Input files must end with '.s2' or '.snappy'.
+Output file names have the extension removed. By default output files will be overwritten.
+Use - as the only file name to read from stdin and write to stdout.
+
+Wildcards are accepted: testdir/*.txt will compress all files in testdir ending with .txt
+Directories can be wildcards as well. testdir/*/*.txt will match testdir/subdir/b.txt
+
+File names beginning with 'http://' and 'https://' will be downloaded and decompressed.
+Extensions on downloaded files are ignored. Only http response code 200 is accepted.
+
+Options:
+  -bench int
+        Run benchmark n times. No output will be written
+  -c    Write all output to stdout. Multiple input files will be concatenated
+  -help
+        Display help
+  -o string
+        Write output to another file. Single input file only
+  -offset string
+        Start at offset. Examples: 92, 64K, 256K, 1M, 4M. Requires Index
+  -q    Don't write any output to terminal, except errors
+  -rm
+        Delete source file(s) after successful decompression
+  -safe
+        Do not overwrite output files
+  -tail string
+        Return last of compressed file. Examples: 92, 64K, 256K, 1M, 4M. Requires Index
+  -verify
+        Verify files, but do not write output                                      
+```
+
+## s2sx: self-extracting archives
+
+s2sx allows creating self-extracting archives with no dependencies.
+
+By default, executables are created for the same platforms as the host os, 
+but this can be overridden with `-os` and `-arch` parameters.
+
+Extracted files have 0666 permissions, except when untar option used.
+
+```
+Usage: s2sx [options] file1 file2
+
+Compresses all files supplied as input separately.
+If files have '.s2' extension they are assumed to be compressed already.
+Output files are written as 'filename.s2sx' and with '.exe' for windows targets.
+If output is big, an additional file with ".more" is written. This must be included as well.
+By default output files will be overwritten.
+
+Wildcards are accepted: testdir/*.txt will compress all files in testdir ending with .txt
+Directories can be wildcards as well. testdir/*/*.txt will match testdir/subdir/b.txt
+
+Options:
+  -arch string
+        Destination architecture (default "amd64")
+  -c    Write all output to stdout. Multiple input files will be concatenated
+  -cpu int
+        Compress using this amount of threads (default 32)
+  -help
+        Display help
+  -max string
+        Maximum executable size. Rest will be written to another file. (default "1G")
+  -os string
+        Destination operating system (default "windows")
+  -q    Don't write any output to terminal, except errors
+  -rm
+        Delete source file(s) after successful compression
+  -safe
+        Do not overwrite output files
+  -untar
+        Untar on destination
+```
+
+Available platforms are:
+
+ * darwin-amd64
+ * darwin-arm64
+ * linux-amd64
+ * linux-arm
+ * linux-arm64
+ * linux-mips64
+ * linux-ppc64le
+ * windows-386
+ * windows-amd64                                                                             
+
+By default, there is a size limit of 1GB for the output executable.
+
+When this is exceeded the remaining file content is written to a file called
+output+`.more`. This file must be included for a successful extraction and 
+placed alongside the executable for a successful extraction.
+
+This file *must* have the same name as the executable, so if the executable is renamed, 
+so must the `.more` file. 
+
+This functionality is disabled with stdin/stdout. 
+
+### Self-extracting TAR files
+
+If you wrap a TAR file you can specify `-untar` to make it untar on the destination host.
+
+Files are extracted to the current folder with the path specified in the tar file.
+
+Note that tar files are not validated before they are wrapped.
+
+For security reasons files that move below the root folder are not allowed.
+
+# Performance
+
+This section will focus on comparisons to Snappy. 
+This package is solely aimed at replacing Snappy as a high speed compression package.
+If you are mainly looking for better compression [zstandard](https://github.com/klauspost/compress/tree/master/zstd#zstd)
+gives better compression, but typically at speeds slightly below "better" mode in this package.
+
+Compression is increased compared to Snappy, mostly around 5-20% and the throughput is typically 25-40% increased (single threaded) compared to the Snappy Go implementation.
+
+Streams are concurrently compressed. The stream will be distributed among all available CPU cores for the best possible throughput.
+
+A "better" compression mode is also available. This allows to trade a bit of speed for a minor compression gain.
+The content compressed in this mode is fully compatible with the standard decoder.
+
+Snappy vs S2 **compression** speed on 16 core (32 thread) computer, using all threads and a single thread (1 CPU):
+
+| File                                                                                                    | S2 Speed | S2 Throughput | S2 % smaller | S2 "better" | "better" throughput | "better" % smaller |
+|---------------------------------------------------------------------------------------------------------|----------|---------------|--------------|-------------|---------------------|--------------------|
+| [rawstudio-mint14.tar](https://files.klauspost.com/compress/rawstudio-mint14.7z)                        | 16.33x   | 10556 MB/s    | 8.0%         | 6.04x       | 5252 MB/s           | 14.7%              |
+| (1 CPU)                                                                                                 | 1.08x    | 940 MB/s      | -            | 0.46x       | 400 MB/s            | -                  |
+| [github-june-2days-2019.json](https://files.klauspost.com/compress/github-june-2days-2019.json.zst)     | 16.51x   | 15224 MB/s    | 31.70%       | 9.47x       | 8734 MB/s           | 37.71%             |
+| (1 CPU)                                                                                                 | 1.26x    | 1157 MB/s     | -            | 0.60x       | 556 MB/s            | -                  |
+| [github-ranks-backup.bin](https://files.klauspost.com/compress/github-ranks-backup.bin.zst)             | 15.14x   | 12598 MB/s    | -5.76%       | 6.23x       | 5675 MB/s           | 3.62%              |
+| (1 CPU)                                                                                                 | 1.02x    | 932 MB/s      | -            | 0.47x       | 432 MB/s            | -                  |
+| [consensus.db.10gb](https://files.klauspost.com/compress/consensus.db.10gb.zst)                         | 11.21x   | 12116 MB/s    | 15.95%       | 3.24x       | 3500 MB/s           | 18.00%             |
+| (1 CPU)                                                                                                 | 1.05x    | 1135 MB/s     | -            | 0.27x       | 292 MB/s            | -                  |
+| [apache.log](https://files.klauspost.com/compress/apache.log.zst)                                       | 8.55x    | 16673 MB/s    | 20.54%       | 5.85x       | 11420 MB/s          | 24.97%             |
+| (1 CPU)                                                                                                 | 1.91x    | 1771 MB/s     | -            | 0.53x       | 1041 MB/s           | -                  |
+| [gob-stream](https://files.klauspost.com/compress/gob-stream.7z)                                        | 15.76x   | 14357 MB/s    | 24.01%       | 8.67x       | 7891 MB/s           | 33.68%             |
+| (1 CPU)                                                                                                 | 1.17x    | 1064 MB/s     | -            | 0.65x       | 595 MB/s            | -                  |
+| [10gb.tar](http://mattmahoney.net/dc/10gb.html)                                                         | 13.33x   | 9835 MB/s     | 2.34%        | 6.85x       | 4863 MB/s           | 9.96%              |
+| (1 CPU)                                                                                                 | 0.97x    | 689 MB/s      | -            | 0.55x       | 387 MB/s            | -                  |
+| sharnd.out.2gb                                                                                          | 9.11x    | 13213 MB/s    | 0.01%        | 1.49x       | 9184 MB/s           | 0.01%              |
+| (1 CPU)                                                                                                 | 0.88x    | 5418 MB/s     | -            | 0.77x       | 5417 MB/s           | -                  |
+| [sofia-air-quality-dataset csv](https://files.klauspost.com/compress/sofia-air-quality-dataset.tar.zst) | 22.00x   | 11477 MB/s    | 18.73%       | 11.15x      | 5817 MB/s           | 27.88%             |
+| (1 CPU)                                                                                                 | 1.23x    | 642 MB/s      | -            | 0.71x       | 642 MB/s            | -                  |
+| [silesia.tar](http://sun.aei.polsl.pl/~sdeor/corpus/silesia.zip)                                        | 11.23x   | 6520 MB/s     | 5.9%         | 5.35x       | 3109 MB/s           | 15.88%             |
+| (1 CPU)                                                                                                 | 1.05x    | 607 MB/s      | -            | 0.52x       | 304 MB/s            | -                  |
+| [enwik9](https://files.klauspost.com/compress/enwik9.zst)                                               | 19.28x   | 8440 MB/s     | 4.04%        | 9.31x       | 4076 MB/s           | 18.04%             |
+| (1 CPU)                                                                                                 | 1.12x    | 488 MB/s      | -            | 0.57x       | 250 MB/s            | -                  |
+
+### Legend
+
+* `S2 Speed`: Speed of S2 compared to Snappy, using 16 cores and 1 core.
+* `S2 Throughput`: Throughput of S2 in MB/s. 
+* `S2 % smaller`: How many percent of the Snappy output size is S2 better.
+* `S2 "better"`: Speed when enabling "better" compression mode in S2 compared to Snappy. 
+* `"better" throughput`: Speed when enabling "better" compression mode in S2 compared to Snappy. 
+* `"better" % smaller`: How many percent of the Snappy output size is S2 better when using "better" compression.
+
+There is a good speedup across the board when using a single thread and a significant speedup when using multiple threads.
+
+Machine generated data gets by far the biggest compression boost, with size being reduced by up to 35% of Snappy size.
+
+The "better" compression mode sees a good improvement in all cases, but usually at a performance cost.
+
+Incompressible content (`sharnd.out.2gb`, 2GB random data) sees the smallest speedup. 
+This is likely dominated by synchronization overhead, which is confirmed by the fact that single threaded performance is higher (see above). 
+
+## Decompression
+
+S2 attempts to create content that is also fast to decompress, except in "better" mode where the smallest representation is used.
+
+S2 vs Snappy **decompression** speed. Both operating on single core:
+
+| File                                                                                                | S2 Throughput | vs. Snappy | Better Throughput | vs. Snappy |
+|-----------------------------------------------------------------------------------------------------|---------------|------------|-------------------|------------|
+| [rawstudio-mint14.tar](https://files.klauspost.com/compress/rawstudio-mint14.7z)                    | 2117 MB/s     | 1.14x      | 1738 MB/s         | 0.94x      |
+| [github-june-2days-2019.json](https://files.klauspost.com/compress/github-june-2days-2019.json.zst) | 2401 MB/s     | 1.25x      | 2307 MB/s         | 1.20x      |
+| [github-ranks-backup.bin](https://files.klauspost.com/compress/github-ranks-backup.bin.zst)         | 2075 MB/s     | 0.98x      | 1764 MB/s         | 0.83x      |
+| [consensus.db.10gb](https://files.klauspost.com/compress/consensus.db.10gb.zst)                     | 2967 MB/s     | 1.05x      | 2885 MB/s         | 1.02x      |
+| [adresser.json](https://files.klauspost.com/compress/adresser.json.zst)                             | 4141 MB/s     | 1.07x      | 4184 MB/s         | 1.08x      |
+| [gob-stream](https://files.klauspost.com/compress/gob-stream.7z)                                    | 2264 MB/s     | 1.12x      | 2185 MB/s         | 1.08x      |
+| [10gb.tar](http://mattmahoney.net/dc/10gb.html)                                                     | 1525 MB/s     | 1.03x      | 1347 MB/s         | 0.91x      |
+| sharnd.out.2gb                                                                                      | 3813 MB/s     | 0.79x      | 3900 MB/s         | 0.81x      |
+| [enwik9](http://mattmahoney.net/dc/textdata.html)                                                   | 1246 MB/s     | 1.29x      | 967 MB/s          | 1.00x      |
+| [silesia.tar](http://sun.aei.polsl.pl/~sdeor/corpus/silesia.zip)                                    | 1433 MB/s     | 1.12x      | 1203 MB/s         | 0.94x      |
+| [enwik10](https://encode.su/threads/3315-enwik10-benchmark-results)                                 | 1284 MB/s     | 1.32x      | 1010 MB/s         | 1.04x      |
+
+### Legend
+
+* `S2 Throughput`: Decompression speed of S2 encoded content.
+* `Better Throughput`: Decompression speed of S2 "better" encoded content.
+* `vs Snappy`: Decompression speed of S2 "better" mode compared to Snappy and absolute speed.
+
+
+While the decompression code hasn't changed, there is a significant speedup in decompression speed. 
+S2 prefers longer matches and will typically only find matches that are 6 bytes or longer. 
+While this reduces compression a bit, it improves decompression speed.
+
+The "better" compression mode will actively look for shorter matches, which is why it has a decompression speed quite similar to Snappy.   
+
+Without assembly decompression is also very fast; single goroutine decompression speed. No assembly:
+
+| File                           | S2 Throughput | S2 throughput |
+|--------------------------------|---------------|---------------|
+| consensus.db.10gb.s2           | 1.84x         | 2289.8 MB/s   |
+| 10gb.tar.s2                    | 1.30x         | 867.07 MB/s   |
+| rawstudio-mint14.tar.s2        | 1.66x         | 1329.65 MB/s  |
+| github-june-2days-2019.json.s2 | 2.36x         | 1831.59 MB/s  |
+| github-ranks-backup.bin.s2     | 1.73x         | 1390.7 MB/s   |
+| enwik9.s2                      | 1.67x         | 681.53 MB/s   |
+| adresser.json.s2               | 3.41x         | 4230.53 MB/s  |
+| silesia.tar.s2                 | 1.52x         | 811.58        |
+
+Even though S2 typically compresses better than Snappy, decompression speed is always better. 
+
+### Concurrent Stream Decompression
+
+For full stream decompression S2 offers a [DecodeConcurrent](https://pkg.go.dev/github.com/klauspost/compress/s2#Reader.DecodeConcurrent) 
+that will decode a full stream using multiple goroutines.
+
+Example scaling, AMD Ryzen 3950X, 16 cores, decompression using `s2d -bench=3 <input>`, best of 3: 
+
+| Input                                     | `-cpu=1`   | `-cpu=2`   | `-cpu=4`   | `-cpu=8`   | `-cpu=16`   |
+|-------------------------------------------|------------|------------|------------|------------|-------------|
+| enwik10.snappy                            | 1098.6MB/s | 1819.8MB/s | 3625.6MB/s | 6910.6MB/s | 10818.2MB/s |
+| enwik10.s2                                | 1303.5MB/s | 2606.1MB/s | 4847.9MB/s | 8878.4MB/s | 9592.1MB/s  |
+| sofia-air-quality-dataset.tar.snappy      | 1302.0MB/s | 2165.0MB/s | 4244.5MB/s | 8241.0MB/s | 12920.5MB/s |
+| sofia-air-quality-dataset.tar.s2          | 1399.2MB/s | 2463.2MB/s | 5196.5MB/s | 9639.8MB/s | 11439.5MB/s |
+| sofia-air-quality-dataset.tar.s2 (no asm) | 837.5MB/s  | 1652.6MB/s | 3183.6MB/s | 5945.0MB/s | 9620.7MB/s  |
+
+Scaling can be expected to be pretty linear until memory bandwidth is saturated. 
+
+For now the DecodeConcurrent can only be used for full streams without seeking or combining with regular reads.
+
+## Block compression
+
+
+When compressing blocks no concurrent compression is performed just as Snappy. 
+This is because blocks are for smaller payloads and generally will not benefit from concurrent compression.
+
+An important change is that incompressible blocks will not be more than at most 10 bytes bigger than the input.
+In rare, worst case scenario Snappy blocks could be significantly bigger than the input.  
+
+### Mixed content blocks
+
+The most reliable is a wide dataset. 
+For this we use [`webdevdata.org-2015-01-07-subset`](https://files.klauspost.com/compress/webdevdata.org-2015-01-07-4GB-subset.7z),
+53927 files, total input size: 4,014,735,833 bytes. Single goroutine used.
+
+| *                 | Input      | Output     | Reduction  | MB/s       |
+|-------------------|------------|------------|------------|------------|
+| S2                | 4014735833 | 1059723369 | 73.60%     | **936.73** |
+| S2 Better         | 4014735833 | 961580539  | 76.05%     | 451.10     |
+| S2 Best           | 4014735833 | 899182886  | **77.60%** | 46.84      |
+| Snappy            | 4014735833 | 1128706759 | 71.89%     | 790.15     |
+| S2, Snappy Output | 4014735833 | 1093823291 | 72.75%     | 936.60     |
+| LZ4               | 4014735833 | 1063768713 | 73.50%     | 452.02     |
+
+S2 delivers both the best single threaded throughput with regular mode and the best compression rate with "best".
+"Better" mode provides the same compression speed as LZ4 with better compression ratio. 
+
+When outputting Snappy compatible output it still delivers better throughput (150MB/s more) and better compression.
+
+As can be seen from the other benchmarks decompression should also be easier on the S2 generated output.
+
+Though they cannot be compared due to different decompression speeds here are the speed/size comparisons for
+other Go compressors:
+
+| *                 | Input      | Output     | Reduction | MB/s   |
+|-------------------|------------|------------|-----------|--------|
+| Zstd Fastest (Go) | 4014735833 | 794608518  | 80.21%    | 236.04 |
+| Zstd Best (Go)    | 4014735833 | 704603356  | 82.45%    | 35.63  |
+| Deflate (Go) l1   | 4014735833 | 871294239  | 78.30%    | 214.04 |
+| Deflate (Go) l9   | 4014735833 | 730389060  | 81.81%    | 41.17  |
+
+### Standard block compression
+
+Benchmarking single block performance is subject to a lot more variation since it only tests a limited number of file patterns.
+So individual benchmarks should only be seen as a guideline and the overall picture is more important.
+
+These micro-benchmarks are with data in cache and trained branch predictors. For a more realistic benchmark see the mixed content above. 
+
+Block compression. Parallel benchmark running on 16 cores, 16 goroutines.
+
+AMD64 assembly is use for both S2 and Snappy.
+
+| Absolute Perf         | Snappy size | S2 Size | Snappy Speed | S2 Speed    | Snappy dec  | S2 dec      |
+|-----------------------|-------------|---------|--------------|-------------|-------------|-------------|
+| html                  | 22843       | 20868   | 16246 MB/s   | 18617 MB/s  | 40972 MB/s  | 49263 MB/s  |
+| urls.10K              | 335492      | 286541  | 7943 MB/s    | 10201 MB/s  | 22523 MB/s  | 26484 MB/s  |
+| fireworks.jpeg        | 123034      | 123100  | 349544 MB/s  | 303228 MB/s | 718321 MB/s | 827552 MB/s |
+| fireworks.jpeg (200B) | 146         | 155     | 8869 MB/s    | 20180 MB/s  | 33691 MB/s  | 52421 MB/s  |
+| paper-100k.pdf        | 85304       | 84202   | 167546 MB/s  | 112988 MB/s | 326905 MB/s | 291944 MB/s |
+| html_x_4              | 92234       | 20870   | 15194 MB/s   | 54457 MB/s  | 30843 MB/s  | 32217 MB/s  |
+| alice29.txt           | 88034       | 85934   | 5936 MB/s    | 6540 MB/s   | 12882 MB/s  | 20044 MB/s  |
+| asyoulik.txt          | 77503       | 79575   | 5517 MB/s    | 6657 MB/s   | 12735 MB/s  | 22806 MB/s  |
+| lcet10.txt            | 234661      | 220383  | 6235 MB/s    | 6303 MB/s   | 14519 MB/s  | 18697 MB/s  |
+| plrabn12.txt          | 319267      | 318196  | 5159 MB/s    | 6074 MB/s   | 11923 MB/s  | 19901 MB/s  |
+| geo.protodata         | 23335       | 18606   | 21220 MB/s   | 25432 MB/s  | 56271 MB/s  | 62540 MB/s  |
+| kppkn.gtb             | 69526       | 65019   | 9732 MB/s    | 8905 MB/s   | 18491 MB/s  | 18969 MB/s  |
+| alice29.txt (128B)    | 80          | 82      | 6691 MB/s    | 17179 MB/s  | 31883 MB/s  | 38874 MB/s  |
+| alice29.txt (1000B)   | 774         | 774     | 12204 MB/s   | 13273 MB/s  | 48056 MB/s  | 52341 MB/s  |
+| alice29.txt (10000B)  | 6648        | 6933    | 10044 MB/s   | 12824 MB/s  | 32378 MB/s  | 46322 MB/s  |
+| alice29.txt (20000B)  | 12686       | 13516   | 7733 MB/s    | 12160 MB/s  | 30566 MB/s  | 58969 MB/s  |
+
+
+Speed is generally at or above Snappy. Small blocks gets a significant speedup, although at the expense of size. 
+
+Decompression speed is better than Snappy, except in one case. 
+
+Since payloads are very small the variance in terms of size is rather big, so they should only be seen as a general guideline.
+
+Size is on average around Snappy, but varies on content type. 
+In cases where compression is worse, it usually is compensated by a speed boost. 
+
+
+### Better compression
+
+Benchmarking single block performance is subject to a lot more variation since it only tests a limited number of file patterns.
+So individual benchmarks should only be seen as a guideline and the overall picture is more important.
+
+| Absolute Perf         | Snappy size | Better Size | Snappy Speed | Better Speed | Snappy dec  | Better dec  |
+|-----------------------|-------------|-------------|--------------|--------------|-------------|-------------|
+| html                  | 22843       | 18972       | 16246 MB/s   | 8621 MB/s    | 40972 MB/s  | 40292 MB/s  |
+| urls.10K              | 335492      | 248079      | 7943 MB/s    | 5104 MB/s    | 22523 MB/s  | 20981 MB/s  |
+| fireworks.jpeg        | 123034      | 123100      | 349544 MB/s  | 84429 MB/s   | 718321 MB/s | 823698 MB/s |
+| fireworks.jpeg (200B) | 146         | 149         | 8869 MB/s    | 7125 MB/s    | 33691 MB/s  | 30101 MB/s  |
+| paper-100k.pdf        | 85304       | 82887       | 167546 MB/s  | 11087 MB/s   | 326905 MB/s | 198869 MB/s |
+| html_x_4              | 92234       | 18982       | 15194 MB/s   | 29316 MB/s   | 30843 MB/s  | 30937 MB/s  |
+| alice29.txt           | 88034       | 71611       | 5936 MB/s    | 3709 MB/s    | 12882 MB/s  | 16611 MB/s  |
+| asyoulik.txt          | 77503       | 65941       | 5517 MB/s    | 3380 MB/s    | 12735 MB/s  | 14975 MB/s  |
+| lcet10.txt            | 234661      | 184939      | 6235 MB/s    | 3537 MB/s    | 14519 MB/s  | 16634 MB/s  |
+| plrabn12.txt          | 319267      | 264990      | 5159 MB/s    | 2960 MB/s    | 11923 MB/s  | 13382 MB/s  |
+| geo.protodata         | 23335       | 17689       | 21220 MB/s   | 10859 MB/s   | 56271 MB/s  | 57961 MB/s  |
+| kppkn.gtb             | 69526       | 55398       | 9732 MB/s    | 5206 MB/s    | 18491 MB/s  | 16524 MB/s  |
+| alice29.txt (128B)    | 80          | 78          | 6691 MB/s    | 7422 MB/s    | 31883 MB/s  | 34225 MB/s  |
+| alice29.txt (1000B)   | 774         | 746         | 12204 MB/s   | 5734 MB/s    | 48056 MB/s  | 42068 MB/s  |
+| alice29.txt (10000B)  | 6648        | 6218        | 10044 MB/s   | 6055 MB/s    | 32378 MB/s  | 28813 MB/s  |
+| alice29.txt (20000B)  | 12686       | 11492       | 7733 MB/s    | 3143 MB/s    | 30566 MB/s  | 27315 MB/s  |
+
+
+Except for the mostly incompressible JPEG image compression is better and usually in the 
+double digits in terms of percentage reduction over Snappy.
+
+The PDF sample shows a significant slowdown compared to Snappy, as this mode tries harder 
+to compress the data. Very small blocks are also not favorable for better compression, so throughput is way down.
+
+This mode aims to provide better compression at the expense of performance and achieves that 
+without a huge performance penalty, except on very small blocks. 
+
+Decompression speed suffers a little compared to the regular S2 mode, 
+but still manages to be close to Snappy in spite of increased compression.  
+ 
+# Best compression mode
+
+S2 offers a "best" compression mode. 
+
+This will compress as much as possible with little regard to CPU usage.
+
+Mainly for offline compression, but where decompression speed should still
+be high and compatible with other S2 compressed data.
+
+Some examples compared on 16 core CPU, amd64 assembly used:
+
+```
+* enwik10
+Default... 10000000000 -> 4759950115 [47.60%]; 1.03s, 9263.0MB/s
+Better...  10000000000 -> 4084706676 [40.85%]; 2.16s, 4415.4MB/s
+Best...    10000000000 -> 3615520079 [36.16%]; 42.259s, 225.7MB/s
+
+* github-june-2days-2019.json
+Default... 6273951764 -> 1041700255 [16.60%]; 431ms, 13882.3MB/s
+Better...  6273951764 -> 945841238 [15.08%]; 547ms, 10938.4MB/s
+Best...    6273951764 -> 826392576 [13.17%]; 9.455s, 632.8MB/s
+
+* nyc-taxi-data-10M.csv
+Default... 3325605752 -> 1093516949 [32.88%]; 324ms, 9788.7MB/s
+Better...  3325605752 -> 885394158 [26.62%]; 491ms, 6459.4MB/s
+Best...    3325605752 -> 773681257 [23.26%]; 8.29s, 412.0MB/s
+
+* 10gb.tar
+Default... 10065157632 -> 5915541066 [58.77%]; 1.028s, 9337.4MB/s
+Better...  10065157632 -> 5453844650 [54.19%]; 1.597s, 4862.7MB/s
+Best...    10065157632 -> 5192495021 [51.59%]; 32.78s, 308.2MB/
+
+* consensus.db.10gb
+Default... 10737418240 -> 4549762344 [42.37%]; 882ms, 12118.4MB/s
+Better...  10737418240 -> 4438535064 [41.34%]; 1.533s, 3500.9MB/s
+Best...    10737418240 -> 4210602774 [39.21%]; 42.96s, 254.4MB/s
+```
+
+Decompression speed should be around the same as using the 'better' compression mode. 
+
+## Dictionaries
+
+*Note: S2 dictionary compression is currently at an early implementation stage, with no assembly for
+neither encoding nor decoding. Performance improvements can be expected in the future.*
+
+Adding dictionaries allow providing a custom dictionary that will serve as lookup in the beginning of blocks.
+
+The same dictionary *must* be used for both encoding and decoding. 
+S2 does not keep track of whether the same dictionary is used,
+and using the wrong dictionary will most often not result in an error when decompressing.
+
+Blocks encoded *without* dictionaries can be decompressed seamlessly *with* a dictionary.
+This means it is possible to switch from an encoding without dictionaries to an encoding with dictionaries
+and treat the blocks similarly.
+
+Similar to [zStandard dictionaries](https://github.com/facebook/zstd#the-case-for-small-data-compression), 
+the same usage scenario applies to S2 dictionaries.  
+
+> Training works if there is some correlation in a family of small data samples. The more data-specific a dictionary is, the more efficient it is (there is no universal dictionary). Hence, deploying one dictionary per type of data will provide the greatest benefits. Dictionary gains are mostly effective in the first few KB. Then, the compression algorithm will gradually use previously decoded content to better compress the rest of the file.
+
+S2 further limits the dictionary to only be enabled on the first 64KB of a block.
+This will remove any negative (speed) impacts of the dictionaries on bigger blocks. 
+
+### Compression
+
+Using the [github_users_sample_set](https://github.com/facebook/zstd/releases/download/v1.1.3/github_users_sample_set.tar.zst) 
+and a 64KB dictionary trained with zStandard the following sizes can be achieved. 
+
+|                    | Default          | Better           | Best                  |
+|--------------------|------------------|------------------|-----------------------|
+| Without Dictionary | 3362023 (44.92%) | 3083163 (41.19%) | 3057944 (40.86%)      |
+| With Dictionary    | 921524 (12.31%)  | 873154 (11.67%)  | 785503 bytes (10.49%) |
+
+So for highly repetitive content, this case provides an almost 3x reduction in size.
+
+For less uniform data we will use the Go source code tree.
+Compressing First 64KB of all `.go` files in `go/src`, Go 1.19.5, 8912 files, 51253563 bytes input:
+
+|                    | Default           | Better            | Best              |
+|--------------------|-------------------|-------------------|-------------------|
+| Without Dictionary | 22955767 (44.79%) | 20189613 (39.39%  | 19482828 (38.01%) |
+| With Dictionary    | 19654568 (38.35%) | 16289357 (31.78%) | 15184589 (29.63%) |
+| Saving/file        | 362 bytes         | 428 bytes         | 472 bytes         |
+
+
+### Creating Dictionaries
+
+There are no tools to create dictionaries in S2. 
+However, there are multiple ways to create a useful dictionary:
+
+#### Using a Sample File
+
+If your input is very uniform, you can just use a sample file as the dictionary.
+
+For example in the `github_users_sample_set` above, the average compression only goes up from 
+10.49% to 11.48% by using the first file as dictionary compared to using a dedicated dictionary.
+
+```Go
+    // Read a sample
+    sample, err := os.ReadFile("sample.json")
+
+    // Create a dictionary.
+    dict := s2.MakeDict(sample, nil)
+        
+    // b := dict.Bytes() will provide a dictionary that can be saved
+    // and reloaded with s2.NewDict(b).
+        
+    // To encode:
+    encoded := dict.Encode(nil, file)
+
+    // To decode:
+    decoded, err := dict.Decode(nil, file)
+```
+
+#### Using Zstandard
+
+Zstandard dictionaries can easily be converted to S2 dictionaries.
+
+This can be helpful to generate dictionaries for files that don't have a fixed structure.
+
+
+Example, with training set files  placed in `./training-set`: 
+
+`λ zstd -r --train-fastcover training-set/* --maxdict=65536 -o name.dict`
+
+This will create a dictionary of 64KB, that can be converted to a dictionary like this:
+
+```Go
+    // Decode the Zstandard dictionary.
+    insp, err := zstd.InspectDictionary(zdict)
+    if err != nil {
+        panic(err)
+    }
+        
+    // We are only interested in the contents.
+    // Assume that files start with "// Copyright (c) 2023".
+    // Search for the longest match for that.
+    // This may save a few bytes.
+    dict := s2.MakeDict(insp.Content(), []byte("// Copyright (c) 2023"))
+
+    // b := dict.Bytes() will provide a dictionary that can be saved
+    // and reloaded with s2.NewDict(b).
+
+    // We can now encode using this dictionary
+    encodedWithDict := dict.Encode(nil, payload)
+
+    // To decode content:
+    decoded, err := dict.Decode(nil, encodedWithDict)
+```
+
+It is recommended to save the dictionary returned by ` b:= dict.Bytes()`, since that will contain only the S2 dictionary.
+
+This dictionary can later be loaded using `s2.NewDict(b)`. The dictionary then no longer requires `zstd` to be initialized.
+
+Also note how `s2.MakeDict` allows you to search for a common starting sequence of your files.
+This can be omitted, at the expense of a few bytes.
+
+# Snappy Compatibility
+
+S2 now offers full compatibility with Snappy.
+
+This means that the efficient encoders of S2 can be used to generate fully Snappy compatible output.
+
+There is a [snappy](https://github.com/klauspost/compress/tree/master/snappy) package that can be used by
+simply changing imports from `github.com/golang/snappy` to `github.com/klauspost/compress/snappy`.
+This uses "better" mode for all operations.
+If you would like more control, you can use the s2 package as described below: 
+
+## Blocks
+
+Snappy compatible blocks can be generated with the S2 encoder. 
+Compression and speed is typically a bit better `MaxEncodedLen` is also smaller for smaller memory usage. Replace 
+
+| Snappy                    | S2 replacement        |
+|---------------------------|-----------------------|
+| snappy.Encode(...)        | s2.EncodeSnappy(...)  |
+| snappy.MaxEncodedLen(...) | s2.MaxEncodedLen(...) |
+
+`s2.EncodeSnappy` can be replaced with `s2.EncodeSnappyBetter` or `s2.EncodeSnappyBest` to get more efficiently compressed snappy compatible output. 
+
+`s2.ConcatBlocks` is compatible with snappy blocks.
+
+Comparison of [`webdevdata.org-2015-01-07-subset`](https://files.klauspost.com/compress/webdevdata.org-2015-01-07-4GB-subset.7z),
+53927 files, total input size: 4,014,735,833 bytes. amd64, single goroutine used:
+
+| Encoder               | Size       | MB/s       | Reduction  |
+|-----------------------|------------|------------|------------|
+| snappy.Encode         | 1128706759 | 725.59     | 71.89%     |
+| s2.EncodeSnappy       | 1093823291 | **899.16** | 72.75%     |
+| s2.EncodeSnappyBetter | 1001158548 | 578.49     | 75.06%     |
+| s2.EncodeSnappyBest   | 944507998  | 66.00      | **76.47%** |
+
+## Streams
+
+For streams, replace `enc = snappy.NewBufferedWriter(w)` with `enc = s2.NewWriter(w, s2.WriterSnappyCompat())`.
+All other options are available, but note that block size limit is different for snappy.
+
+Comparison of different streams, AMD Ryzen 3950x, 16 cores. Size and throughput: 
+
+| File                        | snappy.NewWriter         | S2 Snappy                 | S2 Snappy, Better        | S2 Snappy, Best         |
+|-----------------------------|--------------------------|---------------------------|--------------------------|-------------------------|
+| nyc-taxi-data-10M.csv       | 1316042016 - 539.47MB/s  | 1307003093 - 10132.73MB/s | 1174534014 - 5002.44MB/s | 1115904679 - 177.97MB/s |
+| enwik10 (xml)               | 5088294643 - 451.13MB/s  | 5175840939 -  9440.69MB/s | 4560784526 - 4487.21MB/s | 4340299103 - 158.92MB/s |
+| 10gb.tar (mixed)            | 6056946612 - 729.73MB/s  | 6208571995 -  9978.05MB/s | 5741646126 - 4919.98MB/s | 5548973895 - 180.44MB/s |
+| github-june-2days-2019.json | 1525176492 - 933.00MB/s  | 1476519054 - 13150.12MB/s | 1400547532 - 5803.40MB/s | 1321887137 - 204.29MB/s |
+| consensus.db.10gb (db)      | 5412897703 - 1102.14MB/s | 5354073487 - 13562.91MB/s | 5335069899 - 5294.73MB/s | 5201000954 - 175.72MB/s |
+
+# Decompression
+
+All decompression functions map directly to equivalent s2 functions.
+
+| Snappy                 | S2 replacement     |
+|------------------------|--------------------|
+| snappy.Decode(...)     | s2.Decode(...)     |
+| snappy.DecodedLen(...) | s2.DecodedLen(...) |
+| snappy.NewReader(...)  | s2.NewReader(...)  |
+
+Features like [quick forward skipping without decompression](https://pkg.go.dev/github.com/klauspost/compress/s2#Reader.Skip)
+are also available for Snappy streams.
+
+If you know you are only decompressing snappy streams, setting [`ReaderMaxBlockSize(64<<10)`](https://pkg.go.dev/github.com/klauspost/compress/s2#ReaderMaxBlockSize)
+on your Reader will reduce memory consumption.
+
+# Concatenating blocks and streams.
+
+Concatenating streams will concatenate the output of both without recompressing them. 
+While this is inefficient in terms of compression it might be usable in certain scenarios. 
+The 10 byte 'stream identifier' of the second stream can optionally be stripped, but it is not a requirement.
+
+Blocks can be concatenated using the `ConcatBlocks` function.
+
+Snappy blocks/streams can safely be concatenated with S2 blocks and streams.
+Streams with indexes (see below) will currently not work on concatenated streams.
+
+# Stream Seek Index
+
+S2 and Snappy streams can have indexes. These indexes will allow random seeking within the compressed data.
+
+The index can either be appended to the stream as a skippable block or returned for separate storage.
+
+When the index is appended to a stream it will be skipped by regular decoders, 
+so the output remains compatible with other decoders. 
+
+## Creating an Index
+
+To automatically add an index to a stream, add `WriterAddIndex()` option to your writer.
+Then the index will be added to the stream when `Close()` is called.
+
+```
+        // Add Index to stream...
+        enc := s2.NewWriter(w, s2.WriterAddIndex())
+        io.Copy(enc, r)
+        enc.Close()
+```
+
+If you want to store the index separately, you can use `CloseIndex()` instead of the regular `Close()`.
+This will return the index. Note that `CloseIndex()` should only be called once, and you shouldn't call `Close()`.
+
+```
+        // Get index for separate storage... 
+        enc := s2.NewWriter(w)
+        io.Copy(enc, r)
+        index, err := enc.CloseIndex()
+```
+
+The `index` can then be used needing to read from the stream. 
+This means the index can be used without needing to seek to the end of the stream 
+or for manually forwarding streams. See below.
+
+Finally, an existing S2/Snappy stream can be indexed using the `s2.IndexStream(r io.Reader)` function.
+
+## Using Indexes
+
+To use indexes there is a `ReadSeeker(random bool, index []byte) (*ReadSeeker, error)` function available.
+
+Calling ReadSeeker will return an [io.ReadSeeker](https://pkg.go.dev/io#ReadSeeker) compatible version of the reader.
+
+If 'random' is specified the returned io.Seeker can be used for random seeking, otherwise only forward seeking is supported.
+Enabling random seeking requires the original input to support the [io.Seeker](https://pkg.go.dev/io#Seeker) interface.
+
+```
+        dec := s2.NewReader(r)
+        rs, err := dec.ReadSeeker(false, nil)
+        rs.Seek(wantOffset, io.SeekStart)       
+```
+
+Get a seeker to seek forward. Since no index is provided, the index is read from the stream.
+This requires that an index was added and that `r` supports the [io.Seeker](https://pkg.go.dev/io#Seeker) interface.
+
+A custom index can be specified which will be used if supplied.
+When using a custom index, it will not be read from the input stream.
+
+```
+        dec := s2.NewReader(r)
+        rs, err := dec.ReadSeeker(false, index)
+        rs.Seek(wantOffset, io.SeekStart)       
+```
+
+This will read the index from `index`. Since we specify non-random (forward only) seeking `r` does not have to be an io.Seeker
+
+```
+        dec := s2.NewReader(r)
+        rs, err := dec.ReadSeeker(true, index)
+        rs.Seek(wantOffset, io.SeekStart)       
+```
+
+Finally, since we specify that we want to do random seeking `r` must be an io.Seeker. 
+
+The returned [ReadSeeker](https://pkg.go.dev/github.com/klauspost/compress/s2#ReadSeeker) contains a shallow reference to the existing Reader,
+meaning changes performed to one is reflected in the other.
+
+To check if a stream contains an index at the end, the `(*Index).LoadStream(rs io.ReadSeeker) error` can be used.
+
+## Manually Forwarding Streams
+
+Indexes can also be read outside the decoder using the [Index](https://pkg.go.dev/github.com/klauspost/compress/s2#Index) type.
+This can be used for parsing indexes, either separate or in streams.
+
+In some cases it may not be possible to serve a seekable stream.
+This can for instance be an HTTP stream, where the Range request 
+is sent at the start of the stream. 
+
+With a little bit of extra code it is still possible to use indexes
+to forward to specific offset with a single forward skip. 
+
+It is possible to load the index manually like this: 
+```
+        var index s2.Index
+        _, err = index.Load(idxBytes)
+```
+
+This can be used to figure out how much to offset the compressed stream:
+
+```
+        compressedOffset, uncompressedOffset, err := index.Find(wantOffset)
+```
+
+The `compressedOffset` is the number of bytes that should be skipped 
+from the beginning of the compressed file.
+
+The `uncompressedOffset` will then be offset of the uncompressed bytes returned
+when decoding from that position. This will always be <= wantOffset.
+
+When creating a decoder it must be specified that it should *not* expect a stream identifier
+at the beginning of the stream. Assuming the io.Reader `r` has been forwarded to `compressedOffset`
+we create the decoder like this:
+
+```
+        dec := s2.NewReader(r, s2.ReaderIgnoreStreamIdentifier())
+```
+
+We are not completely done. We still need to forward the stream the uncompressed bytes we didn't want.
+This is done using the regular "Skip" function:
+
+```
+        err = dec.Skip(wantOffset - uncompressedOffset)
+```
+
+This will ensure that we are at exactly the offset we want, and reading from `dec` will start at the requested offset.
+
+# Compact storage
+
+For compact storage [RemoveIndexHeaders](https://pkg.go.dev/github.com/klauspost/compress/s2#RemoveIndexHeaders) can be used to remove any redundant info from 
+a serialized index. If you remove the header it must be restored before [Loading](https://pkg.go.dev/github.com/klauspost/compress/s2#Index.Load).
+
+This is expected to save 20 bytes. These can be restored using [RestoreIndexHeaders](https://pkg.go.dev/github.com/klauspost/compress/s2#RestoreIndexHeaders). This removes a layer of security, but is the most compact representation. Returns nil if headers contains errors.
+
+## Index Format:
+
+Each block is structured as a snappy skippable block, with the chunk ID 0x99.
+
+The block can be read from the front, but contains information so it can be read from the back as well.
+
+Numbers are stored as fixed size little endian values or [zigzag encoded](https://developers.google.com/protocol-buffers/docs/encoding#signed_integers) [base 128 varints](https://developers.google.com/protocol-buffers/docs/encoding), 
+with un-encoded value length of 64 bits, unless other limits are specified. 
+
+| Content                              | Format                                                                                                                        |
+|--------------------------------------|-------------------------------------------------------------------------------------------------------------------------------|
+| ID, `[1]byte`                        | Always 0x99.                                                                                                                  |
+| Data Length, `[3]byte`               | 3 byte little-endian length of the chunk in bytes, following this.                                                            |
+| Header `[6]byte`                     | Header, must be `[115, 50, 105, 100, 120, 0]` or in text: "s2idx\x00".                                                        |
+| UncompressedSize, Varint             | Total Uncompressed size.                                                                                                      |
+| CompressedSize, Varint               | Total Compressed size if known. Should be -1 if unknown.                                                                      |
+| EstBlockSize, Varint                 | Block Size, used for guessing uncompressed offsets. Must be >= 0.                                                             |
+| Entries, Varint                      | Number of Entries in index, must be < 65536 and >=0.                                                                          |
+| HasUncompressedOffsets `byte`        | 0 if no uncompressed offsets are present, 1 if present. Other values are invalid.                                             |
+| UncompressedOffsets, [Entries]VarInt | Uncompressed offsets. See below how to decode.                                                                                |
+| CompressedOffsets, [Entries]VarInt   | Compressed offsets. See below how to decode.                                                                                  |
+| Block Size, `[4]byte`                | Little Endian total encoded size (including header and trailer). Can be used for searching backwards to start of block.       |
+| Trailer `[6]byte`                    | Trailer, must be `[0, 120, 100, 105, 50, 115]` or in text: "\x00xdi2s". Can be used for identifying block from end of stream. |
+
+For regular streams the uncompressed offsets are fully predictable,
+so `HasUncompressedOffsets` allows to specify that compressed blocks all have 
+exactly `EstBlockSize` bytes of uncompressed content.
+
+Entries *must* be in order, starting with the lowest offset, 
+and there *must* be no uncompressed offset duplicates.  
+Entries *may* point to the start of a skippable block, 
+but it is then not allowed to also have an entry for the next block since 
+that would give an uncompressed offset duplicate.
+
+There is no requirement for all blocks to be represented in the index. 
+In fact there is a maximum of 65536 block entries in an index.
+
+The writer can use any method to reduce the number of entries.
+An implicit block start at 0,0 can be assumed.
+
+### Decoding entries:
+
+```
+// Read Uncompressed entries.
+// Each assumes EstBlockSize delta from previous.
+for each entry {
+    uOff = 0
+    if HasUncompressedOffsets == 1 {
+        uOff = ReadVarInt // Read value from stream
+    }
+   
+    // Except for the first entry, use previous values.
+    if entryNum == 0 {
+        entry[entryNum].UncompressedOffset = uOff
+        continue
+    }
+    
+    // Uncompressed uses previous offset and adds EstBlockSize
+    entry[entryNum].UncompressedOffset = entry[entryNum-1].UncompressedOffset + EstBlockSize + uOff
+}
+
+
+// Guess that the first block will be 50% of uncompressed size.
+// Integer truncating division must be used.
+CompressGuess := EstBlockSize / 2
+
+// Read Compressed entries.
+// Each assumes CompressGuess delta from previous.
+// CompressGuess is adjusted for each value.
+for each entry {
+    cOff = ReadVarInt // Read value from stream
+    
+    // Except for the first entry, use previous values.
+    if entryNum == 0 {
+        entry[entryNum].CompressedOffset = cOff
+        continue
+    }
+    
+    // Compressed uses previous and our estimate.
+    entry[entryNum].CompressedOffset = entry[entryNum-1].CompressedOffset + CompressGuess + cOff
+        
+     // Adjust compressed offset for next loop, integer truncating division must be used. 
+     CompressGuess += cOff/2               
+}
+```
+
+To decode from any given uncompressed offset `(wantOffset)`:
+
+* Iterate entries until `entry[n].UncompressedOffset > wantOffset`.
+* Start decoding from `entry[n-1].CompressedOffset`.
+* Discard `entry[n-1].UncompressedOffset - wantOffset` bytes from the decoded stream.
+
+See [using indexes](https://github.com/klauspost/compress/tree/master/s2#using-indexes) for functions that perform the operations with a simpler interface.
+
+
+# Format Extensions
+
+* Frame [Stream identifier](https://github.com/google/snappy/blob/master/framing_format.txt#L68) changed from `sNaPpY` to `S2sTwO`.
+* [Framed compressed blocks](https://github.com/google/snappy/blob/master/format_description.txt) can be up to 4MB (up from 64KB).
+* Compressed blocks can have an offset of `0`, which indicates to repeat the last seen offset.
+
+Repeat offsets must be encoded as a [2.2.1. Copy with 1-byte offset (01)](https://github.com/google/snappy/blob/master/format_description.txt#L89), where the offset is 0.
+
+The length is specified by reading the 3-bit length specified in the tag and decode using this table:
+
+| Length | Actual Length        |
+|--------|----------------------|
+| 0      | 4                    |
+| 1      | 5                    |
+| 2      | 6                    |
+| 3      | 7                    |
+| 4      | 8                    |
+| 5      | 8 + read 1 byte      |
+| 6      | 260 + read 2 bytes   |
+| 7      | 65540 + read 3 bytes |
+
+This allows any repeat offset + length to be represented by 2 to 5 bytes.
+It also allows to emit matches longer than 64 bytes with one copy + one repeat instead of several 64 byte copies.
+
+Lengths are stored as little endian values.
+
+The first copy of a block cannot be a repeat offset and the offset is reset on every block in streams.
+
+Default streaming block size is 1MB.
+
+# Dictionary Encoding
+
+Adding dictionaries allow providing a custom dictionary that will serve as lookup in the beginning of blocks.
+
+A dictionary provides an initial repeat value that can be used to point to a common header.
+
+Other than that the dictionary contains values that can be used as back-references.
+
+Often used data should be placed at the *end* of the dictionary since offsets < 2048 bytes will be smaller.
+
+## Format
+
+Dictionary *content* must at least 16 bytes and less or equal to 64KiB (65536 bytes).
+
+Encoding: `[repeat value (uvarint)][dictionary content...]`
+
+Before the dictionary content, an unsigned base-128 (uvarint) encoded value specifying the initial repeat offset.
+This value is an offset into the dictionary content and not a back-reference offset,
+so setting this to 0 will make the repeat value point to the first value of the dictionary.
+
+The value must be less than the dictionary length-8
+
+## Encoding
+
+From the decoder point of view the dictionary content is seen as preceding the encoded content.
+
+`[dictionary content][decoded output]`
+
+Backreferences to the dictionary are encoded as ordinary backreferences that have an offset before the start of the decoded block.
+
+Matches copying from the dictionary are **not** allowed to cross from the dictionary into the decoded data.
+However, if a copy ends at the end of the dictionary the next repeat will point to the start of the decoded buffer, which is allowed.
+
+The first match can be a repeat value, which will use the repeat offset stored in the dictionary.
+
+When 64KB (65536 bytes) has been en/decoded it is no longer allowed to reference the dictionary, 
+neither by a copy nor repeat operations. 
+If the boundary is crossed while copying from the dictionary, the operation should complete, 
+but the next instruction is not allowed to reference the dictionary.
+
+Valid blocks encoded *without* a dictionary can be decoded with any dictionary. 
+There are no checks whether the supplied dictionary is the correct for a block.
+Because of this there is no overhead by using a dictionary.
+
+## Example
+
+This is the dictionary content. Elements are separated by `[]`.
+
+Dictionary: `[0x0a][Yesterday 25 bananas were added to Benjamins brown bag]`.
+
+Initial repeat offset is set at 10, which is the letter `2`.
+
+Encoded `[LIT "10"][REPEAT len=10][LIT "hich"][MATCH off=50 len=6][MATCH off=31 len=6][MATCH off=61 len=10]`
+
+Decoded: `[10][ bananas w][hich][ were ][brown ][were added]`
+
+Output: `10 bananas which were brown were added`
+
+
+## Streams
+
+For streams each block can use the dictionary.
+
+The dictionary cannot not currently be provided on the stream.
+
+
+# LICENSE
+
+This code is based on the [Snappy-Go](https://github.com/golang/snappy) implementation.
+
+Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
diff --git a/vendor/github.com/klauspost/compress/s2/decode.go b/vendor/github.com/klauspost/compress/s2/decode.go
new file mode 100644
index 0000000..6c7feaf
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/decode.go
@@ -0,0 +1,437 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Copyright (c) 2019 Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s2
+
+import (
+        "encoding/binary"
+        "errors"
+        "fmt"
+        "strconv"
+)
+
+var (
+        // ErrCorrupt reports that the input is invalid.
+        ErrCorrupt = errors.New("s2: corrupt input")
+        // ErrCRC reports that the input failed CRC validation (streams only)
+        ErrCRC = errors.New("s2: corrupt input, crc mismatch")
+        // ErrTooLarge reports that the uncompressed length is too large.
+        ErrTooLarge = errors.New("s2: decoded block is too large")
+        // ErrUnsupported reports that the input isn't supported.
+        ErrUnsupported = errors.New("s2: unsupported input")
+)
+
+// DecodedLen returns the length of the decoded block.
+func DecodedLen(src []byte) (int, error) {
+        v, _, err := decodedLen(src)
+        return v, err
+}
+
+// decodedLen returns the length of the decoded block and the number of bytes
+// that the length header occupied.
+func decodedLen(src []byte) (blockLen, headerLen int, err error) {
+        v, n := binary.Uvarint(src)
+        if n <= 0 || v > 0xffffffff {
+                return 0, 0, ErrCorrupt
+        }
+
+        const wordSize = 32 << (^uint(0) >> 32 & 1)
+        if wordSize == 32 && v > 0x7fffffff {
+                return 0, 0, ErrTooLarge
+        }
+        return int(v), n, nil
+}
+
+const (
+        decodeErrCodeCorrupt = 1
+)
+
+// Decode returns the decoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire decoded block.
+// Otherwise, a newly allocated slice will be returned.
+//
+// The dst and src must not overlap. It is valid to pass a nil dst.
+func Decode(dst, src []byte) ([]byte, error) {
+        dLen, s, err := decodedLen(src)
+        if err != nil {
+                return nil, err
+        }
+        if dLen <= cap(dst) {
+                dst = dst[:dLen]
+        } else {
+                dst = make([]byte, dLen)
+        }
+        if s2Decode(dst, src[s:]) != 0 {
+                return nil, ErrCorrupt
+        }
+        return dst, nil
+}
+
+// s2DecodeDict writes the decoding of src to dst. It assumes that the varint-encoded
+// length of the decompressed bytes has already been read, and that len(dst)
+// equals that length.
+//
+// It returns 0 on success or a decodeErrCodeXxx error code on failure.
+func s2DecodeDict(dst, src []byte, dict *Dict) int {
+        if dict == nil {
+                return s2Decode(dst, src)
+        }
+        const debug = false
+        const debugErrs = debug
+
+        if debug {
+                fmt.Println("Starting decode, dst len:", len(dst))
+        }
+        var d, s, length int
+        offset := len(dict.dict) - dict.repeat
+
+        // As long as we can read at least 5 bytes...
+        for s < len(src)-5 {
+                // Removing bounds checks is SLOWER, when if doing
+                // in := src[s:s+5]
+                // Checked on Go 1.18
+                switch src[s] & 0x03 {
+                case tagLiteral:
+                        x := uint32(src[s] >> 2)
+                        switch {
+                        case x < 60:
+                                s++
+                        case x == 60:
+                                s += 2
+                                x = uint32(src[s-1])
+                        case x == 61:
+                                in := src[s : s+3]
+                                x = uint32(in[1]) | uint32(in[2])<<8
+                                s += 3
+                        case x == 62:
+                                in := src[s : s+4]
+                                // Load as 32 bit and shift down.
+                                x = uint32(in[0]) | uint32(in[1])<<8 | uint32(in[2])<<16 | uint32(in[3])<<24
+                                x >>= 8
+                                s += 4
+                        case x == 63:
+                                in := src[s : s+5]
+                                x = uint32(in[1]) | uint32(in[2])<<8 | uint32(in[3])<<16 | uint32(in[4])<<24
+                                s += 5
+                        }
+                        length = int(x) + 1
+                        if debug {
+                                fmt.Println("literals, length:", length, "d-after:", d+length)
+                        }
+                        if length > len(dst)-d || length > len(src)-s || (strconv.IntSize == 32 && length <= 0) {
+                                if debugErrs {
+                                        fmt.Println("corrupt literal: length:", length, "d-left:", len(dst)-d, "src-left:", len(src)-s)
+                                }
+                                return decodeErrCodeCorrupt
+                        }
+
+                        copy(dst[d:], src[s:s+length])
+                        d += length
+                        s += length
+                        continue
+
+                case tagCopy1:
+                        s += 2
+                        toffset := int(uint32(src[s-2])&0xe0<<3 | uint32(src[s-1]))
+                        length = int(src[s-2]) >> 2 & 0x7
+                        if toffset == 0 {
+                                if debug {
+                                        fmt.Print("(repeat) ")
+                                }
+                                // keep last offset
+                                switch length {
+                                case 5:
+                                        length = int(src[s]) + 4
+                                        s += 1
+                                case 6:
+                                        in := src[s : s+2]
+                                        length = int(uint32(in[0])|(uint32(in[1])<<8)) + (1 << 8)
+                                        s += 2
+                                case 7:
+                                        in := src[s : s+3]
+                                        length = int((uint32(in[2])<<16)|(uint32(in[1])<<8)|uint32(in[0])) + (1 << 16)
+                                        s += 3
+                                default: // 0-> 4
+                                }
+                        } else {
+                                offset = toffset
+                        }
+                        length += 4
+                case tagCopy2:
+                        in := src[s : s+3]
+                        offset = int(uint32(in[1]) | uint32(in[2])<<8)
+                        length = 1 + int(in[0])>>2
+                        s += 3
+
+                case tagCopy4:
+                        in := src[s : s+5]
+                        offset = int(uint32(in[1]) | uint32(in[2])<<8 | uint32(in[3])<<16 | uint32(in[4])<<24)
+                        length = 1 + int(in[0])>>2
+                        s += 5
+                }
+
+                if offset <= 0 || length > len(dst)-d {
+                        if debugErrs {
+                                fmt.Println("match error; offset:", offset, "length:", length, "dst-left:", len(dst)-d)
+                        }
+                        return decodeErrCodeCorrupt
+                }
+
+                // copy from dict
+                if d < offset {
+                        if d > MaxDictSrcOffset {
+                                if debugErrs {
+                                        fmt.Println("dict after", MaxDictSrcOffset, "d:", d, "offset:", offset, "length:", length)
+                                }
+                                return decodeErrCodeCorrupt
+                        }
+                        startOff := len(dict.dict) - offset + d
+                        if startOff < 0 || startOff+length > len(dict.dict) {
+                                if debugErrs {
+                                        fmt.Printf("offset (%d) + length (%d) bigger than dict (%d)\n", offset, length, len(dict.dict))
+                                }
+                                return decodeErrCodeCorrupt
+                        }
+                        if debug {
+                                fmt.Println("dict copy, length:", length, "offset:", offset, "d-after:", d+length, "dict start offset:", startOff)
+                        }
+                        copy(dst[d:d+length], dict.dict[startOff:])
+                        d += length
+                        continue
+                }
+
+                if debug {
+                        fmt.Println("copy, length:", length, "offset:", offset, "d-after:", d+length)
+                }
+
+                // Copy from an earlier sub-slice of dst to a later sub-slice.
+                // If no overlap, use the built-in copy:
+                if offset > length {
+                        copy(dst[d:d+length], dst[d-offset:])
+                        d += length
+                        continue
+                }
+
+                // Unlike the built-in copy function, this byte-by-byte copy always runs
+                // forwards, even if the slices overlap. Conceptually, this is:
+                //
+                // d += forwardCopy(dst[d:d+length], dst[d-offset:])
+                //
+                // We align the slices into a and b and show the compiler they are the same size.
+                // This allows the loop to run without bounds checks.
+                a := dst[d : d+length]
+                b := dst[d-offset:]
+                b = b[:len(a)]
+                for i := range a {
+                        a[i] = b[i]
+                }
+                d += length
+        }
+
+        // Remaining with extra checks...
+        for s < len(src) {
+                switch src[s] & 0x03 {
+                case tagLiteral:
+                        x := uint32(src[s] >> 2)
+                        switch {
+                        case x < 60:
+                                s++
+                        case x == 60:
+                                s += 2
+                                if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                        if debugErrs {
+                                                fmt.Println("src went oob")
+                                        }
+                                        return decodeErrCodeCorrupt
+                                }
+                                x = uint32(src[s-1])
+                        case x == 61:
+                                s += 3
+                                if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                        if debugErrs {
+                                                fmt.Println("src went oob")
+                                        }
+                                        return decodeErrCodeCorrupt
+                                }
+                                x = uint32(src[s-2]) | uint32(src[s-1])<<8
+                        case x == 62:
+                                s += 4
+                                if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                        if debugErrs {
+                                                fmt.Println("src went oob")
+                                        }
+                                        return decodeErrCodeCorrupt
+                                }
+                                x = uint32(src[s-3]) | uint32(src[s-2])<<8 | uint32(src[s-1])<<16
+                        case x == 63:
+                                s += 5
+                                if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                        if debugErrs {
+                                                fmt.Println("src went oob")
+                                        }
+                                        return decodeErrCodeCorrupt
+                                }
+                                x = uint32(src[s-4]) | uint32(src[s-3])<<8 | uint32(src[s-2])<<16 | uint32(src[s-1])<<24
+                        }
+                        length = int(x) + 1
+                        if length > len(dst)-d || length > len(src)-s || (strconv.IntSize == 32 && length <= 0) {
+                                if debugErrs {
+                                        fmt.Println("corrupt literal: length:", length, "d-left:", len(dst)-d, "src-left:", len(src)-s)
+                                }
+                                return decodeErrCodeCorrupt
+                        }
+                        if debug {
+                                fmt.Println("literals, length:", length, "d-after:", d+length)
+                        }
+
+                        copy(dst[d:], src[s:s+length])
+                        d += length
+                        s += length
+                        continue
+
+                case tagCopy1:
+                        s += 2
+                        if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                if debugErrs {
+                                        fmt.Println("src went oob")
+                                }
+                                return decodeErrCodeCorrupt
+                        }
+                        length = int(src[s-2]) >> 2 & 0x7
+                        toffset := int(uint32(src[s-2])&0xe0<<3 | uint32(src[s-1]))
+                        if toffset == 0 {
+                                if debug {
+                                        fmt.Print("(repeat) ")
+                                }
+                                // keep last offset
+                                switch length {
+                                case 5:
+                                        s += 1
+                                        if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                                if debugErrs {
+                                                        fmt.Println("src went oob")
+                                                }
+                                                return decodeErrCodeCorrupt
+                                        }
+                                        length = int(uint32(src[s-1])) + 4
+                                case 6:
+                                        s += 2
+                                        if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                                if debugErrs {
+                                                        fmt.Println("src went oob")
+                                                }
+                                                return decodeErrCodeCorrupt
+                                        }
+                                        length = int(uint32(src[s-2])|(uint32(src[s-1])<<8)) + (1 << 8)
+                                case 7:
+                                        s += 3
+                                        if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                                if debugErrs {
+                                                        fmt.Println("src went oob")
+                                                }
+                                                return decodeErrCodeCorrupt
+                                        }
+                                        length = int(uint32(src[s-3])|(uint32(src[s-2])<<8)|(uint32(src[s-1])<<16)) + (1 << 16)
+                                default: // 0-> 4
+                                }
+                        } else {
+                                offset = toffset
+                        }
+                        length += 4
+                case tagCopy2:
+                        s += 3
+                        if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                if debugErrs {
+                                        fmt.Println("src went oob")
+                                }
+                                return decodeErrCodeCorrupt
+                        }
+                        length = 1 + int(src[s-3])>>2
+                        offset = int(uint32(src[s-2]) | uint32(src[s-1])<<8)
+
+                case tagCopy4:
+                        s += 5
+                        if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                if debugErrs {
+                                        fmt.Println("src went oob")
+                                }
+                                return decodeErrCodeCorrupt
+                        }
+                        length = 1 + int(src[s-5])>>2
+                        offset = int(uint32(src[s-4]) | uint32(src[s-3])<<8 | uint32(src[s-2])<<16 | uint32(src[s-1])<<24)
+                }
+
+                if offset <= 0 || length > len(dst)-d {
+                        if debugErrs {
+                                fmt.Println("match error; offset:", offset, "length:", length, "dst-left:", len(dst)-d)
+                        }
+                        return decodeErrCodeCorrupt
+                }
+
+                // copy from dict
+                if d < offset {
+                        if d > MaxDictSrcOffset {
+                                if debugErrs {
+                                        fmt.Println("dict after", MaxDictSrcOffset, "d:", d, "offset:", offset, "length:", length)
+                                }
+                                return decodeErrCodeCorrupt
+                        }
+                        rOff := len(dict.dict) - (offset - d)
+                        if debug {
+                                fmt.Println("starting dict entry from dict offset", len(dict.dict)-rOff)
+                        }
+                        if rOff+length > len(dict.dict) {
+                                if debugErrs {
+                                        fmt.Println("err: END offset", rOff+length, "bigger than dict", len(dict.dict), "dict offset:", rOff, "length:", length)
+                                }
+                                return decodeErrCodeCorrupt
+                        }
+                        if rOff < 0 {
+                                if debugErrs {
+                                        fmt.Println("err: START offset", rOff, "less than 0", len(dict.dict), "dict offset:", rOff, "length:", length)
+                                }
+                                return decodeErrCodeCorrupt
+                        }
+                        copy(dst[d:d+length], dict.dict[rOff:])
+                        d += length
+                        continue
+                }
+
+                if debug {
+                        fmt.Println("copy, length:", length, "offset:", offset, "d-after:", d+length)
+                }
+
+                // Copy from an earlier sub-slice of dst to a later sub-slice.
+                // If no overlap, use the built-in copy:
+                if offset > length {
+                        copy(dst[d:d+length], dst[d-offset:])
+                        d += length
+                        continue
+                }
+
+                // Unlike the built-in copy function, this byte-by-byte copy always runs
+                // forwards, even if the slices overlap. Conceptually, this is:
+                //
+                // d += forwardCopy(dst[d:d+length], dst[d-offset:])
+                //
+                // We align the slices into a and b and show the compiler they are the same size.
+                // This allows the loop to run without bounds checks.
+                a := dst[d : d+length]
+                b := dst[d-offset:]
+                b = b[:len(a)]
+                for i := range a {
+                        a[i] = b[i]
+                }
+                d += length
+        }
+
+        if d != len(dst) {
+                if debugErrs {
+                        fmt.Println("wanted length", len(dst), "got", d)
+                }
+                return decodeErrCodeCorrupt
+        }
+        return 0
+}
diff --git a/vendor/github.com/klauspost/compress/s2/decode_amd64.s b/vendor/github.com/klauspost/compress/s2/decode_amd64.s
new file mode 100644
index 0000000..9b105e0
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/decode_amd64.s
@@ -0,0 +1,568 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Copyright (c) 2019 Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+// +build gc
+// +build !noasm
+
+#include "textflag.h"
+
+#define R_TMP0 AX
+#define R_TMP1 BX
+#define R_LEN CX
+#define R_OFF DX
+#define R_SRC SI
+#define R_DST DI
+#define R_DBASE R8
+#define R_DLEN R9
+#define R_DEND R10
+#define R_SBASE R11
+#define R_SLEN R12
+#define R_SEND R13
+#define R_TMP2 R14
+#define R_TMP3 R15
+
+// The asm code generally follows the pure Go code in decode_other.go, except
+// where marked with a "!!!".
+
+// func decode(dst, src []byte) int
+//
+// All local variables fit into registers. The non-zero stack size is only to
+// spill registers and push args when issuing a CALL. The register allocation:
+//      - R_TMP0        scratch
+//      - R_TMP1        scratch
+//      - R_LEN     length or x (shared)
+//      - R_OFF     offset
+//      - R_SRC     &src[s]
+//      - R_DST     &dst[d]
+//      + R_DBASE       dst_base
+//      + R_DLEN        dst_len
+//      + R_DEND        dst_base + dst_len
+//      + R_SBASE       src_base
+//      + R_SLEN        src_len
+//      + R_SEND        src_base + src_len
+//      - R_TMP2        used by doCopy
+//      - R_TMP3        used by doCopy
+//
+// The registers R_DBASE-R_SEND (marked with a "+") are set at the start of the
+// function, and after a CALL returns, and are not otherwise modified.
+//
+// The d variable is implicitly R_DST - R_DBASE,  and len(dst)-d is R_DEND - R_DST.
+// The s variable is implicitly R_SRC - R_SBASE, and len(src)-s is R_SEND - R_SRC.
+TEXT ·s2Decode(SB), NOSPLIT, $48-56
+        // Initialize R_SRC, R_DST and R_DBASE-R_SEND.
+        MOVQ dst_base+0(FP), R_DBASE
+        MOVQ dst_len+8(FP), R_DLEN
+        MOVQ R_DBASE, R_DST
+        MOVQ R_DBASE, R_DEND
+        ADDQ R_DLEN, R_DEND
+        MOVQ src_base+24(FP), R_SBASE
+        MOVQ src_len+32(FP), R_SLEN
+        MOVQ R_SBASE, R_SRC
+        MOVQ R_SBASE, R_SEND
+        ADDQ R_SLEN, R_SEND
+        XORQ R_OFF, R_OFF
+
+loop:
+        // for s < len(src)
+        CMPQ R_SRC, R_SEND
+        JEQ  end
+
+        // R_LEN = uint32(src[s])
+        //
+        // switch src[s] & 0x03
+        MOVBLZX (R_SRC), R_LEN
+        MOVL    R_LEN, R_TMP1
+        ANDL    $3, R_TMP1
+        CMPL    R_TMP1, $1
+        JAE     tagCopy
+
+        // ----------------------------------------
+        // The code below handles literal tags.
+
+        // case tagLiteral:
+        // x := uint32(src[s] >> 2)
+        // switch
+        SHRL $2, R_LEN
+        CMPL R_LEN, $60
+        JAE  tagLit60Plus
+
+        // case x < 60:
+        // s++
+        INCQ R_SRC
+
+doLit:
+        // This is the end of the inner "switch", when we have a literal tag.
+        //
+        // We assume that R_LEN == x and x fits in a uint32, where x is the variable
+        // used in the pure Go decode_other.go code.
+
+        // length = int(x) + 1
+        //
+        // Unlike the pure Go code, we don't need to check if length <= 0 because
+        // R_LEN can hold 64 bits, so the increment cannot overflow.
+        INCQ R_LEN
+
+        // Prepare to check if copying length bytes will run past the end of dst or
+        // src.
+        //
+        // R_TMP0 = len(dst) - d
+        // R_TMP1 = len(src) - s
+        MOVQ R_DEND, R_TMP0
+        SUBQ R_DST, R_TMP0
+        MOVQ R_SEND, R_TMP1
+        SUBQ R_SRC, R_TMP1
+
+        // !!! Try a faster technique for short (16 or fewer bytes) copies.
+        //
+        // if length > 16 || len(dst)-d < 16 || len(src)-s < 16 {
+        //   goto callMemmove // Fall back on calling runtime·memmove.
+        // }
+        //
+        // The C++ snappy code calls this TryFastAppend. It also checks len(src)-s
+        // against 21 instead of 16, because it cannot assume that all of its input
+        // is contiguous in memory and so it needs to leave enough source bytes to
+        // read the next tag without refilling buffers, but Go's Decode assumes
+        // contiguousness (the src argument is a []byte).
+        CMPQ R_LEN, $16
+        JGT  callMemmove
+        CMPQ R_TMP0, $16
+        JLT  callMemmove
+        CMPQ R_TMP1, $16
+        JLT  callMemmove
+
+        // !!! Implement the copy from src to dst as a 16-byte load and store.
+        // (Decode's documentation says that dst and src must not overlap.)
+        //
+        // This always copies 16 bytes, instead of only length bytes, but that's
+        // OK. If the input is a valid Snappy encoding then subsequent iterations
+        // will fix up the overrun. Otherwise, Decode returns a nil []byte (and a
+        // non-nil error), so the overrun will be ignored.
+        //
+        // Note that on amd64, it is legal and cheap to issue unaligned 8-byte or
+        // 16-byte loads and stores. This technique probably wouldn't be as
+        // effective on architectures that are fussier about alignment.
+        MOVOU 0(R_SRC), X0
+        MOVOU X0, 0(R_DST)
+
+        // d += length
+        // s += length
+        ADDQ R_LEN, R_DST
+        ADDQ R_LEN, R_SRC
+        JMP  loop
+
+callMemmove:
+        // if length > len(dst)-d || length > len(src)-s { etc }
+        CMPQ R_LEN, R_TMP0
+        JGT  errCorrupt
+        CMPQ R_LEN, R_TMP1
+        JGT  errCorrupt
+
+        // copy(dst[d:], src[s:s+length])
+        //
+        // This means calling runtime·memmove(&dst[d], &src[s], length), so we push
+        // R_DST, R_SRC and R_LEN as arguments. Coincidentally, we also need to spill those
+        // three registers to the stack, to save local variables across the CALL.
+        MOVQ R_DST, 0(SP)
+        MOVQ R_SRC, 8(SP)
+        MOVQ R_LEN, 16(SP)
+        MOVQ R_DST, 24(SP)
+        MOVQ R_SRC, 32(SP)
+        MOVQ R_LEN, 40(SP)
+        MOVQ R_OFF, 48(SP)
+        CALL runtime·memmove(SB)
+
+        // Restore local variables: unspill registers from the stack and
+        // re-calculate R_DBASE-R_SEND.
+        MOVQ 24(SP), R_DST
+        MOVQ 32(SP), R_SRC
+        MOVQ 40(SP), R_LEN
+        MOVQ 48(SP), R_OFF
+        MOVQ dst_base+0(FP), R_DBASE
+        MOVQ dst_len+8(FP), R_DLEN
+        MOVQ R_DBASE, R_DEND
+        ADDQ R_DLEN, R_DEND
+        MOVQ src_base+24(FP), R_SBASE
+        MOVQ src_len+32(FP), R_SLEN
+        MOVQ R_SBASE, R_SEND
+        ADDQ R_SLEN, R_SEND
+
+        // d += length
+        // s += length
+        ADDQ R_LEN, R_DST
+        ADDQ R_LEN, R_SRC
+        JMP  loop
+
+tagLit60Plus:
+        // !!! This fragment does the
+        //
+        // s += x - 58; if uint(s) > uint(len(src)) { etc }
+        //
+        // checks. In the asm version, we code it once instead of once per switch case.
+        ADDQ R_LEN, R_SRC
+        SUBQ $58, R_SRC
+        CMPQ R_SRC, R_SEND
+        JA   errCorrupt
+
+        // case x == 60:
+        CMPL R_LEN, $61
+        JEQ  tagLit61
+        JA   tagLit62Plus
+
+        // x = uint32(src[s-1])
+        MOVBLZX -1(R_SRC), R_LEN
+        JMP     doLit
+
+tagLit61:
+        // case x == 61:
+        // x = uint32(src[s-2]) | uint32(src[s-1])<<8
+        MOVWLZX -2(R_SRC), R_LEN
+        JMP     doLit
+
+tagLit62Plus:
+        CMPL R_LEN, $62
+        JA   tagLit63
+
+        // case x == 62:
+        // x = uint32(src[s-3]) | uint32(src[s-2])<<8 | uint32(src[s-1])<<16
+        // We read one byte, safe to read one back, since we are just reading tag.
+        // x = binary.LittleEndian.Uint32(src[s-1:]) >> 8
+        MOVL -4(R_SRC), R_LEN
+        SHRL $8, R_LEN
+        JMP  doLit
+
+tagLit63:
+        // case x == 63:
+        // x = uint32(src[s-4]) | uint32(src[s-3])<<8 | uint32(src[s-2])<<16 | uint32(src[s-1])<<24
+        MOVL -4(R_SRC), R_LEN
+        JMP  doLit
+
+// The code above handles literal tags.
+// ----------------------------------------
+// The code below handles copy tags.
+
+tagCopy4:
+        // case tagCopy4:
+        // s += 5
+        ADDQ $5, R_SRC
+
+        // if uint(s) > uint(len(src)) { etc }
+        CMPQ R_SRC, R_SEND
+        JA   errCorrupt
+
+        // length = 1 + int(src[s-5])>>2
+        SHRQ $2, R_LEN
+        INCQ R_LEN
+
+        // offset = int(uint32(src[s-4]) | uint32(src[s-3])<<8 | uint32(src[s-2])<<16 | uint32(src[s-1])<<24)
+        MOVLQZX -4(R_SRC), R_OFF
+        JMP     doCopy
+
+tagCopy2:
+        // case tagCopy2:
+        // s += 3
+        ADDQ $3, R_SRC
+
+        // if uint(s) > uint(len(src)) { etc }
+        CMPQ R_SRC, R_SEND
+        JA   errCorrupt
+
+        // length = 1 + int(src[s-3])>>2
+        SHRQ $2, R_LEN
+        INCQ R_LEN
+
+        // offset = int(uint32(src[s-2]) | uint32(src[s-1])<<8)
+        MOVWQZX -2(R_SRC), R_OFF
+        JMP     doCopy
+
+tagCopy:
+        // We have a copy tag. We assume that:
+        //      - R_TMP1 == src[s] & 0x03
+        //      - R_LEN == src[s]
+        CMPQ R_TMP1, $2
+        JEQ  tagCopy2
+        JA   tagCopy4
+
+        // case tagCopy1:
+        // s += 2
+        ADDQ $2, R_SRC
+
+        // if uint(s) > uint(len(src)) { etc }
+        CMPQ R_SRC, R_SEND
+        JA   errCorrupt
+
+        // offset = int(uint32(src[s-2])&0xe0<<3 | uint32(src[s-1]))
+        // length = 4 + int(src[s-2])>>2&0x7
+        MOVBQZX -1(R_SRC), R_TMP1
+        MOVQ    R_LEN, R_TMP0
+        SHRQ    $2, R_LEN
+        ANDQ    $0xe0, R_TMP0
+        ANDQ    $7, R_LEN
+        SHLQ    $3, R_TMP0
+        ADDQ    $4, R_LEN
+        ORQ     R_TMP1, R_TMP0
+
+        // check if repeat code, ZF set by ORQ.
+        JZ repeatCode
+
+        // This is a regular copy, transfer our temporary value to R_OFF (length)
+        MOVQ R_TMP0, R_OFF
+        JMP  doCopy
+
+// This is a repeat code.
+repeatCode:
+        // If length < 9, reuse last offset, with the length already calculated.
+        CMPQ R_LEN, $9
+        JL   doCopyRepeat
+
+        // Read additional bytes for length.
+        JE repeatLen1
+
+        // Rare, so the extra branch shouldn't hurt too much.
+        CMPQ R_LEN, $10
+        JE   repeatLen2
+        JMP  repeatLen3
+
+// Read repeat lengths.
+repeatLen1:
+        // s ++
+        ADDQ $1, R_SRC
+
+        // if uint(s) > uint(len(src)) { etc }
+        CMPQ R_SRC, R_SEND
+        JA   errCorrupt
+
+        // length = src[s-1] + 8
+        MOVBQZX -1(R_SRC), R_LEN
+        ADDL    $8, R_LEN
+        JMP     doCopyRepeat
+
+repeatLen2:
+        // s +=2
+        ADDQ $2, R_SRC
+
+        // if uint(s) > uint(len(src)) { etc }
+        CMPQ R_SRC, R_SEND
+        JA   errCorrupt
+
+        // length = uint32(src[s-2]) | (uint32(src[s-1])<<8) + (1 << 8)
+        MOVWQZX -2(R_SRC), R_LEN
+        ADDL    $260, R_LEN
+        JMP     doCopyRepeat
+
+repeatLen3:
+        // s +=3
+        ADDQ $3, R_SRC
+
+        // if uint(s) > uint(len(src)) { etc }
+        CMPQ R_SRC, R_SEND
+        JA   errCorrupt
+
+        // length = uint32(src[s-3]) | (uint32(src[s-2])<<8) | (uint32(src[s-1])<<16) + (1 << 16)
+        // Read one byte further back (just part of the tag, shifted out)
+        MOVL -4(R_SRC), R_LEN
+        SHRL $8, R_LEN
+        ADDL $65540, R_LEN
+        JMP  doCopyRepeat
+
+doCopy:
+        // This is the end of the outer "switch", when we have a copy tag.
+        //
+        // We assume that:
+        //      - R_LEN == length && R_LEN > 0
+        //      - R_OFF == offset
+
+        // if d < offset { etc }
+        MOVQ R_DST, R_TMP1
+        SUBQ R_DBASE, R_TMP1
+        CMPQ R_TMP1, R_OFF
+        JLT  errCorrupt
+
+        // Repeat values can skip the test above, since any offset > 0 will be in dst.
+doCopyRepeat:
+        // if offset <= 0 { etc }
+        CMPQ R_OFF, $0
+        JLE  errCorrupt
+
+        // if length > len(dst)-d { etc }
+        MOVQ R_DEND, R_TMP1
+        SUBQ R_DST, R_TMP1
+        CMPQ R_LEN, R_TMP1
+        JGT  errCorrupt
+
+        // forwardCopy(dst[d:d+length], dst[d-offset:]); d += length
+        //
+        // Set:
+        //      - R_TMP2 = len(dst)-d
+        //      - R_TMP3 = &dst[d-offset]
+        MOVQ R_DEND, R_TMP2
+        SUBQ R_DST, R_TMP2
+        MOVQ R_DST, R_TMP3
+        SUBQ R_OFF, R_TMP3
+
+        // !!! Try a faster technique for short (16 or fewer bytes) forward copies.
+        //
+        // First, try using two 8-byte load/stores, similar to the doLit technique
+        // above. Even if dst[d:d+length] and dst[d-offset:] can overlap, this is
+        // still OK if offset >= 8. Note that this has to be two 8-byte load/stores
+        // and not one 16-byte load/store, and the first store has to be before the
+        // second load, due to the overlap if offset is in the range [8, 16).
+        //
+        // if length > 16 || offset < 8 || len(dst)-d < 16 {
+        //   goto slowForwardCopy
+        // }
+        // copy 16 bytes
+        // d += length
+        CMPQ R_LEN, $16
+        JGT  slowForwardCopy
+        CMPQ R_OFF, $8
+        JLT  slowForwardCopy
+        CMPQ R_TMP2, $16
+        JLT  slowForwardCopy
+        MOVQ 0(R_TMP3), R_TMP0
+        MOVQ R_TMP0, 0(R_DST)
+        MOVQ 8(R_TMP3), R_TMP1
+        MOVQ R_TMP1, 8(R_DST)
+        ADDQ R_LEN, R_DST
+        JMP  loop
+
+slowForwardCopy:
+        // !!! If the forward copy is longer than 16 bytes, or if offset < 8, we
+        // can still try 8-byte load stores, provided we can overrun up to 10 extra
+        // bytes. As above, the overrun will be fixed up by subsequent iterations
+        // of the outermost loop.
+        //
+        // The C++ snappy code calls this technique IncrementalCopyFastPath. Its
+        // commentary says:
+        //
+        // ----
+        //
+        // The main part of this loop is a simple copy of eight bytes at a time
+        // until we've copied (at least) the requested amount of bytes.  However,
+        // if d and d-offset are less than eight bytes apart (indicating a
+        // repeating pattern of length < 8), we first need to expand the pattern in
+        // order to get the correct results. For instance, if the buffer looks like
+        // this, with the eight-byte <d-offset> and <d> patterns marked as
+        // intervals:
+        //
+        //    abxxxxxxxxxxxx
+        //    [------]           d-offset
+        //      [------]         d
+        //
+        // a single eight-byte copy from <d-offset> to <d> will repeat the pattern
+        // once, after which we can move <d> two bytes without moving <d-offset>:
+        //
+        //    ababxxxxxxxxxx
+        //    [------]           d-offset
+        //        [------]       d
+        //
+        // and repeat the exercise until the two no longer overlap.
+        //
+        // This allows us to do very well in the special case of one single byte
+        // repeated many times, without taking a big hit for more general cases.
+        //
+        // The worst case of extra writing past the end of the match occurs when
+        // offset == 1 and length == 1; the last copy will read from byte positions
+        // [0..7] and write to [4..11], whereas it was only supposed to write to
+        // position 1. Thus, ten excess bytes.
+        //
+        // ----
+        //
+        // That "10 byte overrun" worst case is confirmed by Go's
+        // TestSlowForwardCopyOverrun, which also tests the fixUpSlowForwardCopy
+        // and finishSlowForwardCopy algorithm.
+        //
+        // if length > len(dst)-d-10 {
+        //   goto verySlowForwardCopy
+        // }
+        SUBQ $10, R_TMP2
+        CMPQ R_LEN, R_TMP2
+        JGT  verySlowForwardCopy
+
+        // We want to keep the offset, so we use R_TMP2 from here.
+        MOVQ R_OFF, R_TMP2
+
+makeOffsetAtLeast8:
+        // !!! As above, expand the pattern so that offset >= 8 and we can use
+        // 8-byte load/stores.
+        //
+        // for offset < 8 {
+        //   copy 8 bytes from dst[d-offset:] to dst[d:]
+        //   length -= offset
+        //   d      += offset
+        //   offset += offset
+        //   // The two previous lines together means that d-offset, and therefore
+        //   // R_TMP3, is unchanged.
+        // }
+        CMPQ R_TMP2, $8
+        JGE  fixUpSlowForwardCopy
+        MOVQ (R_TMP3), R_TMP1
+        MOVQ R_TMP1, (R_DST)
+        SUBQ R_TMP2, R_LEN
+        ADDQ R_TMP2, R_DST
+        ADDQ R_TMP2, R_TMP2
+        JMP  makeOffsetAtLeast8
+
+fixUpSlowForwardCopy:
+        // !!! Add length (which might be negative now) to d (implied by R_DST being
+        // &dst[d]) so that d ends up at the right place when we jump back to the
+        // top of the loop. Before we do that, though, we save R_DST to R_TMP0 so that, if
+        // length is positive, copying the remaining length bytes will write to the
+        // right place.
+        MOVQ R_DST, R_TMP0
+        ADDQ R_LEN, R_DST
+
+finishSlowForwardCopy:
+        // !!! Repeat 8-byte load/stores until length <= 0. Ending with a negative
+        // length means that we overrun, but as above, that will be fixed up by
+        // subsequent iterations of the outermost loop.
+        CMPQ R_LEN, $0
+        JLE  loop
+        MOVQ (R_TMP3), R_TMP1
+        MOVQ R_TMP1, (R_TMP0)
+        ADDQ $8, R_TMP3
+        ADDQ $8, R_TMP0
+        SUBQ $8, R_LEN
+        JMP  finishSlowForwardCopy
+
+verySlowForwardCopy:
+        // verySlowForwardCopy is a simple implementation of forward copy. In C
+        // parlance, this is a do/while loop instead of a while loop, since we know
+        // that length > 0. In Go syntax:
+        //
+        // for {
+        //   dst[d] = dst[d - offset]
+        //   d++
+        //   length--
+        //   if length == 0 {
+        //     break
+        //   }
+        // }
+        MOVB (R_TMP3), R_TMP1
+        MOVB R_TMP1, (R_DST)
+        INCQ R_TMP3
+        INCQ R_DST
+        DECQ R_LEN
+        JNZ  verySlowForwardCopy
+        JMP  loop
+
+// The code above handles copy tags.
+// ----------------------------------------
+
+end:
+        // This is the end of the "for s < len(src)".
+        //
+        // if d != len(dst) { etc }
+        CMPQ R_DST, R_DEND
+        JNE  errCorrupt
+
+        // return 0
+        MOVQ $0, ret+48(FP)
+        RET
+
+errCorrupt:
+        // return decodeErrCodeCorrupt
+        MOVQ $1, ret+48(FP)
+        RET
diff --git a/vendor/github.com/klauspost/compress/s2/decode_arm64.s b/vendor/github.com/klauspost/compress/s2/decode_arm64.s
new file mode 100644
index 0000000..4b63d50
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/decode_arm64.s
@@ -0,0 +1,574 @@
+// Copyright 2020 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.
+
+// +build !appengine
+// +build gc
+// +build !noasm
+
+#include "textflag.h"
+
+#define R_TMP0 R2
+#define R_TMP1 R3
+#define R_LEN R4
+#define R_OFF R5
+#define R_SRC R6
+#define R_DST R7
+#define R_DBASE R8
+#define R_DLEN R9
+#define R_DEND R10
+#define R_SBASE R11
+#define R_SLEN R12
+#define R_SEND R13
+#define R_TMP2 R14
+#define R_TMP3 R15
+
+// TEST_SRC will check if R_SRC is <= SRC_END
+#define TEST_SRC() \
+        CMP R_SEND, R_SRC \
+        BGT errCorrupt
+
+// MOVD R_SRC, R_TMP1
+// SUB  R_SBASE, R_TMP1, R_TMP1
+// CMP  R_SLEN, R_TMP1
+// BGT  errCorrupt
+
+// The asm code generally follows the pure Go code in decode_other.go, except
+// where marked with a "!!!".
+
+// func decode(dst, src []byte) int
+//
+// All local variables fit into registers. The non-zero stack size is only to
+// spill registers and push args when issuing a CALL. The register allocation:
+//      - R_TMP0        scratch
+//      - R_TMP1        scratch
+//      - R_LEN length or x
+//      - R_OFF offset
+//      - R_SRC &src[s]
+//      - R_DST &dst[d]
+//      + R_DBASE       dst_base
+//      + R_DLEN        dst_len
+//      + R_DEND        dst_base + dst_len
+//      + R_SBASE       src_base
+//      + R_SLEN        src_len
+//      + R_SEND        src_base + src_len
+//      - R_TMP2        used by doCopy
+//      - R_TMP3        used by doCopy
+//
+// The registers R_DBASE-R_SEND (marked with a "+") are set at the start of the
+// function, and after a CALL returns, and are not otherwise modified.
+//
+// The d variable is implicitly R_DST - R_DBASE,  and len(dst)-d is R_DEND - R_DST.
+// The s variable is implicitly R_SRC - R_SBASE, and len(src)-s is R_SEND - R_SRC.
+TEXT ·s2Decode(SB), NOSPLIT, $56-64
+        // Initialize R_SRC, R_DST and R_DBASE-R_SEND.
+        MOVD dst_base+0(FP), R_DBASE
+        MOVD dst_len+8(FP), R_DLEN
+        MOVD R_DBASE, R_DST
+        MOVD R_DBASE, R_DEND
+        ADD  R_DLEN, R_DEND, R_DEND
+        MOVD src_base+24(FP), R_SBASE
+        MOVD src_len+32(FP), R_SLEN
+        MOVD R_SBASE, R_SRC
+        MOVD R_SBASE, R_SEND
+        ADD  R_SLEN, R_SEND, R_SEND
+        MOVD $0, R_OFF
+
+loop:
+        // for s < len(src)
+        CMP R_SEND, R_SRC
+        BEQ end
+
+        // R_LEN = uint32(src[s])
+        //
+        // switch src[s] & 0x03
+        MOVBU (R_SRC), R_LEN
+        MOVW  R_LEN, R_TMP1
+        ANDW  $3, R_TMP1
+        MOVW  $1, R1
+        CMPW  R1, R_TMP1
+        BGE   tagCopy
+
+        // ----------------------------------------
+        // The code below handles literal tags.
+
+        // case tagLiteral:
+        // x := uint32(src[s] >> 2)
+        // switch
+        MOVW $60, R1
+        LSRW $2, R_LEN, R_LEN
+        CMPW R_LEN, R1
+        BLS  tagLit60Plus
+
+        // case x < 60:
+        // s++
+        ADD $1, R_SRC, R_SRC
+
+doLit:
+        // This is the end of the inner "switch", when we have a literal tag.
+        //
+        // We assume that R_LEN == x and x fits in a uint32, where x is the variable
+        // used in the pure Go decode_other.go code.
+
+        // length = int(x) + 1
+        //
+        // Unlike the pure Go code, we don't need to check if length <= 0 because
+        // R_LEN can hold 64 bits, so the increment cannot overflow.
+        ADD $1, R_LEN, R_LEN
+
+        // Prepare to check if copying length bytes will run past the end of dst or
+        // src.
+        //
+        // R_TMP0 = len(dst) - d
+        // R_TMP1 = len(src) - s
+        MOVD R_DEND, R_TMP0
+        SUB  R_DST, R_TMP0, R_TMP0
+        MOVD R_SEND, R_TMP1
+        SUB  R_SRC, R_TMP1, R_TMP1
+
+        // !!! Try a faster technique for short (16 or fewer bytes) copies.
+        //
+        // if length > 16 || len(dst)-d < 16 || len(src)-s < 16 {
+        //   goto callMemmove // Fall back on calling runtime·memmove.
+        // }
+        //
+        // The C++ snappy code calls this TryFastAppend. It also checks len(src)-s
+        // against 21 instead of 16, because it cannot assume that all of its input
+        // is contiguous in memory and so it needs to leave enough source bytes to
+        // read the next tag without refilling buffers, but Go's Decode assumes
+        // contiguousness (the src argument is a []byte).
+        CMP $16, R_LEN
+        BGT callMemmove
+        CMP $16, R_TMP0
+        BLT callMemmove
+        CMP $16, R_TMP1
+        BLT callMemmove
+
+        // !!! Implement the copy from src to dst as a 16-byte load and store.
+        // (Decode's documentation says that dst and src must not overlap.)
+        //
+        // This always copies 16 bytes, instead of only length bytes, but that's
+        // OK. If the input is a valid Snappy encoding then subsequent iterations
+        // will fix up the overrun. Otherwise, Decode returns a nil []byte (and a
+        // non-nil error), so the overrun will be ignored.
+        //
+        // Note that on arm64, it is legal and cheap to issue unaligned 8-byte or
+        // 16-byte loads and stores. This technique probably wouldn't be as
+        // effective on architectures that are fussier about alignment.
+        LDP 0(R_SRC), (R_TMP2, R_TMP3)
+        STP (R_TMP2, R_TMP3), 0(R_DST)
+
+        // d += length
+        // s += length
+        ADD R_LEN, R_DST, R_DST
+        ADD R_LEN, R_SRC, R_SRC
+        B   loop
+
+callMemmove:
+        // if length > len(dst)-d || length > len(src)-s { etc }
+        CMP R_TMP0, R_LEN
+        BGT errCorrupt
+        CMP R_TMP1, R_LEN
+        BGT errCorrupt
+
+        // copy(dst[d:], src[s:s+length])
+        //
+        // This means calling runtime·memmove(&dst[d], &src[s], length), so we push
+        // R_DST, R_SRC and R_LEN as arguments. Coincidentally, we also need to spill those
+        // three registers to the stack, to save local variables across the CALL.
+        MOVD R_DST, 8(RSP)
+        MOVD R_SRC, 16(RSP)
+        MOVD R_LEN, 24(RSP)
+        MOVD R_DST, 32(RSP)
+        MOVD R_SRC, 40(RSP)
+        MOVD R_LEN, 48(RSP)
+        MOVD R_OFF, 56(RSP)
+        CALL runtime·memmove(SB)
+
+        // Restore local variables: unspill registers from the stack and
+        // re-calculate R_DBASE-R_SEND.
+        MOVD 32(RSP), R_DST
+        MOVD 40(RSP), R_SRC
+        MOVD 48(RSP), R_LEN
+        MOVD 56(RSP), R_OFF
+        MOVD dst_base+0(FP), R_DBASE
+        MOVD dst_len+8(FP), R_DLEN
+        MOVD R_DBASE, R_DEND
+        ADD  R_DLEN, R_DEND, R_DEND
+        MOVD src_base+24(FP), R_SBASE
+        MOVD src_len+32(FP), R_SLEN
+        MOVD R_SBASE, R_SEND
+        ADD  R_SLEN, R_SEND, R_SEND
+
+        // d += length
+        // s += length
+        ADD R_LEN, R_DST, R_DST
+        ADD R_LEN, R_SRC, R_SRC
+        B   loop
+
+tagLit60Plus:
+        // !!! This fragment does the
+        //
+        // s += x - 58; if uint(s) > uint(len(src)) { etc }
+        //
+        // checks. In the asm version, we code it once instead of once per switch case.
+        ADD R_LEN, R_SRC, R_SRC
+        SUB $58, R_SRC, R_SRC
+        TEST_SRC()
+
+        // case x == 60:
+        MOVW $61, R1
+        CMPW R1, R_LEN
+        BEQ  tagLit61
+        BGT  tagLit62Plus
+
+        // x = uint32(src[s-1])
+        MOVBU -1(R_SRC), R_LEN
+        B     doLit
+
+tagLit61:
+        // case x == 61:
+        // x = uint32(src[s-2]) | uint32(src[s-1])<<8
+        MOVHU -2(R_SRC), R_LEN
+        B     doLit
+
+tagLit62Plus:
+        CMPW $62, R_LEN
+        BHI  tagLit63
+
+        // case x == 62:
+        // x = uint32(src[s-3]) | uint32(src[s-2])<<8 | uint32(src[s-1])<<16
+        MOVHU -3(R_SRC), R_LEN
+        MOVBU -1(R_SRC), R_TMP1
+        ORR   R_TMP1<<16, R_LEN
+        B     doLit
+
+tagLit63:
+        // case x == 63:
+        // x = uint32(src[s-4]) | uint32(src[s-3])<<8 | uint32(src[s-2])<<16 | uint32(src[s-1])<<24
+        MOVWU -4(R_SRC), R_LEN
+        B     doLit
+
+        // The code above handles literal tags.
+        // ----------------------------------------
+        // The code below handles copy tags.
+
+tagCopy4:
+        // case tagCopy4:
+        // s += 5
+        ADD $5, R_SRC, R_SRC
+
+        // if uint(s) > uint(len(src)) { etc }
+        MOVD R_SRC, R_TMP1
+        SUB  R_SBASE, R_TMP1, R_TMP1
+        CMP  R_SLEN, R_TMP1
+        BGT  errCorrupt
+
+        // length = 1 + int(src[s-5])>>2
+        MOVD $1, R1
+        ADD  R_LEN>>2, R1, R_LEN
+
+        // offset = int(uint32(src[s-4]) | uint32(src[s-3])<<8 | uint32(src[s-2])<<16 | uint32(src[s-1])<<24)
+        MOVWU -4(R_SRC), R_OFF
+        B     doCopy
+
+tagCopy2:
+        // case tagCopy2:
+        // s += 3
+        ADD $3, R_SRC, R_SRC
+
+        // if uint(s) > uint(len(src)) { etc }
+        TEST_SRC()
+
+        // length = 1 + int(src[s-3])>>2
+        MOVD $1, R1
+        ADD  R_LEN>>2, R1, R_LEN
+
+        // offset = int(uint32(src[s-2]) | uint32(src[s-1])<<8)
+        MOVHU -2(R_SRC), R_OFF
+        B     doCopy
+
+tagCopy:
+        // We have a copy tag. We assume that:
+        //      - R_TMP1 == src[s] & 0x03
+        //      - R_LEN == src[s]
+        CMP $2, R_TMP1
+        BEQ tagCopy2
+        BGT tagCopy4
+
+        // case tagCopy1:
+        // s += 2
+        ADD $2, R_SRC, R_SRC
+
+        // if uint(s) > uint(len(src)) { etc }
+        TEST_SRC()
+
+        // offset = int(uint32(src[s-2])&0xe0<<3 | uint32(src[s-1]))
+        // Calculate offset in R_TMP0 in case it is a repeat.
+        MOVD  R_LEN, R_TMP0
+        AND   $0xe0, R_TMP0
+        MOVBU -1(R_SRC), R_TMP1
+        ORR   R_TMP0<<3, R_TMP1, R_TMP0
+
+        // length = 4 + int(src[s-2])>>2&0x7
+        MOVD $7, R1
+        AND  R_LEN>>2, R1, R_LEN
+        ADD  $4, R_LEN, R_LEN
+
+        // check if repeat code with offset 0.
+        CMP $0, R_TMP0
+        BEQ repeatCode
+
+        // This is a regular copy, transfer our temporary value to R_OFF (offset)
+        MOVD R_TMP0, R_OFF
+        B    doCopy
+
+        // This is a repeat code.
+repeatCode:
+        // If length < 9, reuse last offset, with the length already calculated.
+        CMP $9, R_LEN
+        BLT doCopyRepeat
+        BEQ repeatLen1
+        CMP $10, R_LEN
+        BEQ repeatLen2
+
+repeatLen3:
+        // s +=3
+        ADD $3, R_SRC, R_SRC
+
+        // if uint(s) > uint(len(src)) { etc }
+        TEST_SRC()
+
+        // length = uint32(src[s-3]) | (uint32(src[s-2])<<8) | (uint32(src[s-1])<<16) + 65540
+        MOVBU -1(R_SRC), R_TMP0
+        MOVHU -3(R_SRC), R_LEN
+        ORR   R_TMP0<<16, R_LEN, R_LEN
+        ADD   $65540, R_LEN, R_LEN
+        B     doCopyRepeat
+
+repeatLen2:
+        // s +=2
+        ADD $2, R_SRC, R_SRC
+
+        // if uint(s) > uint(len(src)) { etc }
+        TEST_SRC()
+
+        // length = uint32(src[s-2]) | (uint32(src[s-1])<<8) + 260
+        MOVHU -2(R_SRC), R_LEN
+        ADD   $260, R_LEN, R_LEN
+        B     doCopyRepeat
+
+repeatLen1:
+        // s +=1
+        ADD $1, R_SRC, R_SRC
+
+        // if uint(s) > uint(len(src)) { etc }
+        TEST_SRC()
+
+        // length = src[s-1] + 8
+        MOVBU -1(R_SRC), R_LEN
+        ADD   $8, R_LEN, R_LEN
+        B     doCopyRepeat
+
+doCopy:
+        // This is the end of the outer "switch", when we have a copy tag.
+        //
+        // We assume that:
+        //      - R_LEN == length && R_LEN > 0
+        //      - R_OFF == offset
+
+        // if d < offset { etc }
+        MOVD R_DST, R_TMP1
+        SUB  R_DBASE, R_TMP1, R_TMP1
+        CMP  R_OFF, R_TMP1
+        BLT  errCorrupt
+
+        // Repeat values can skip the test above, since any offset > 0 will be in dst.
+doCopyRepeat:
+
+        // if offset <= 0 { etc }
+        CMP $0, R_OFF
+        BLE errCorrupt
+
+        // if length > len(dst)-d { etc }
+        MOVD R_DEND, R_TMP1
+        SUB  R_DST, R_TMP1, R_TMP1
+        CMP  R_TMP1, R_LEN
+        BGT  errCorrupt
+
+        // forwardCopy(dst[d:d+length], dst[d-offset:]); d += length
+        //
+        // Set:
+        //      - R_TMP2 = len(dst)-d
+        //      - R_TMP3 = &dst[d-offset]
+        MOVD R_DEND, R_TMP2
+        SUB  R_DST, R_TMP2, R_TMP2
+        MOVD R_DST, R_TMP3
+        SUB  R_OFF, R_TMP3, R_TMP3
+
+        // !!! Try a faster technique for short (16 or fewer bytes) forward copies.
+        //
+        // First, try using two 8-byte load/stores, similar to the doLit technique
+        // above. Even if dst[d:d+length] and dst[d-offset:] can overlap, this is
+        // still OK if offset >= 8. Note that this has to be two 8-byte load/stores
+        // and not one 16-byte load/store, and the first store has to be before the
+        // second load, due to the overlap if offset is in the range [8, 16).
+        //
+        // if length > 16 || offset < 8 || len(dst)-d < 16 {
+        //   goto slowForwardCopy
+        // }
+        // copy 16 bytes
+        // d += length
+        CMP  $16, R_LEN
+        BGT  slowForwardCopy
+        CMP  $8, R_OFF
+        BLT  slowForwardCopy
+        CMP  $16, R_TMP2
+        BLT  slowForwardCopy
+        MOVD 0(R_TMP3), R_TMP0
+        MOVD R_TMP0, 0(R_DST)
+        MOVD 8(R_TMP3), R_TMP1
+        MOVD R_TMP1, 8(R_DST)
+        ADD  R_LEN, R_DST, R_DST
+        B    loop
+
+slowForwardCopy:
+        // !!! If the forward copy is longer than 16 bytes, or if offset < 8, we
+        // can still try 8-byte load stores, provided we can overrun up to 10 extra
+        // bytes. As above, the overrun will be fixed up by subsequent iterations
+        // of the outermost loop.
+        //
+        // The C++ snappy code calls this technique IncrementalCopyFastPath. Its
+        // commentary says:
+        //
+        // ----
+        //
+        // The main part of this loop is a simple copy of eight bytes at a time
+        // until we've copied (at least) the requested amount of bytes.  However,
+        // if d and d-offset are less than eight bytes apart (indicating a
+        // repeating pattern of length < 8), we first need to expand the pattern in
+        // order to get the correct results. For instance, if the buffer looks like
+        // this, with the eight-byte <d-offset> and <d> patterns marked as
+        // intervals:
+        //
+        //    abxxxxxxxxxxxx
+        //    [------]           d-offset
+        //      [------]         d
+        //
+        // a single eight-byte copy from <d-offset> to <d> will repeat the pattern
+        // once, after which we can move <d> two bytes without moving <d-offset>:
+        //
+        //    ababxxxxxxxxxx
+        //    [------]           d-offset
+        //        [------]       d
+        //
+        // and repeat the exercise until the two no longer overlap.
+        //
+        // This allows us to do very well in the special case of one single byte
+        // repeated many times, without taking a big hit for more general cases.
+        //
+        // The worst case of extra writing past the end of the match occurs when
+        // offset == 1 and length == 1; the last copy will read from byte positions
+        // [0..7] and write to [4..11], whereas it was only supposed to write to
+        // position 1. Thus, ten excess bytes.
+        //
+        // ----
+        //
+        // That "10 byte overrun" worst case is confirmed by Go's
+        // TestSlowForwardCopyOverrun, which also tests the fixUpSlowForwardCopy
+        // and finishSlowForwardCopy algorithm.
+        //
+        // if length > len(dst)-d-10 {
+        //   goto verySlowForwardCopy
+        // }
+        SUB $10, R_TMP2, R_TMP2
+        CMP R_TMP2, R_LEN
+        BGT verySlowForwardCopy
+
+        // We want to keep the offset, so we use R_TMP2 from here.
+        MOVD R_OFF, R_TMP2
+
+makeOffsetAtLeast8:
+        // !!! As above, expand the pattern so that offset >= 8 and we can use
+        // 8-byte load/stores.
+        //
+        // for offset < 8 {
+        //   copy 8 bytes from dst[d-offset:] to dst[d:]
+        //   length -= offset
+        //   d      += offset
+        //   offset += offset
+        //   // The two previous lines together means that d-offset, and therefore
+        //   // R_TMP3, is unchanged.
+        // }
+        CMP  $8, R_TMP2
+        BGE  fixUpSlowForwardCopy
+        MOVD (R_TMP3), R_TMP1
+        MOVD R_TMP1, (R_DST)
+        SUB  R_TMP2, R_LEN, R_LEN
+        ADD  R_TMP2, R_DST, R_DST
+        ADD  R_TMP2, R_TMP2, R_TMP2
+        B    makeOffsetAtLeast8
+
+fixUpSlowForwardCopy:
+        // !!! Add length (which might be negative now) to d (implied by R_DST being
+        // &dst[d]) so that d ends up at the right place when we jump back to the
+        // top of the loop. Before we do that, though, we save R_DST to R_TMP0 so that, if
+        // length is positive, copying the remaining length bytes will write to the
+        // right place.
+        MOVD R_DST, R_TMP0
+        ADD  R_LEN, R_DST, R_DST
+
+finishSlowForwardCopy:
+        // !!! Repeat 8-byte load/stores until length <= 0. Ending with a negative
+        // length means that we overrun, but as above, that will be fixed up by
+        // subsequent iterations of the outermost loop.
+        MOVD $0, R1
+        CMP  R1, R_LEN
+        BLE  loop
+        MOVD (R_TMP3), R_TMP1
+        MOVD R_TMP1, (R_TMP0)
+        ADD  $8, R_TMP3, R_TMP3
+        ADD  $8, R_TMP0, R_TMP0
+        SUB  $8, R_LEN, R_LEN
+        B    finishSlowForwardCopy
+
+verySlowForwardCopy:
+        // verySlowForwardCopy is a simple implementation of forward copy. In C
+        // parlance, this is a do/while loop instead of a while loop, since we know
+        // that length > 0. In Go syntax:
+        //
+        // for {
+        //   dst[d] = dst[d - offset]
+        //   d++
+        //   length--
+        //   if length == 0 {
+        //     break
+        //   }
+        // }
+        MOVB (R_TMP3), R_TMP1
+        MOVB R_TMP1, (R_DST)
+        ADD  $1, R_TMP3, R_TMP3
+        ADD  $1, R_DST, R_DST
+        SUB  $1, R_LEN, R_LEN
+        CBNZ R_LEN, verySlowForwardCopy
+        B    loop
+
+        // The code above handles copy tags.
+        // ----------------------------------------
+
+end:
+        // This is the end of the "for s < len(src)".
+        //
+        // if d != len(dst) { etc }
+        CMP R_DEND, R_DST
+        BNE errCorrupt
+
+        // return 0
+        MOVD $0, ret+48(FP)
+        RET
+
+errCorrupt:
+        // return decodeErrCodeCorrupt
+        MOVD $1, R_TMP0
+        MOVD R_TMP0, ret+48(FP)
+        RET
diff --git a/vendor/github.com/klauspost/compress/s2/decode_asm.go b/vendor/github.com/klauspost/compress/s2/decode_asm.go
new file mode 100644
index 0000000..cb3576e
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/decode_asm.go
@@ -0,0 +1,17 @@
+// Copyright 2016 The Snappy-Go Authors. All rights reserved.
+// Copyright (c) 2019 Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build (amd64 || arm64) && !appengine && gc && !noasm
+// +build amd64 arm64
+// +build !appengine
+// +build gc
+// +build !noasm
+
+package s2
+
+// decode has the same semantics as in decode_other.go.
+//
+//go:noescape
+func s2Decode(dst, src []byte) int
diff --git a/vendor/github.com/klauspost/compress/s2/decode_other.go b/vendor/github.com/klauspost/compress/s2/decode_other.go
new file mode 100644
index 0000000..2cb55c2
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/decode_other.go
@@ -0,0 +1,292 @@
+// Copyright 2016 The Snappy-Go Authors. All rights reserved.
+// Copyright (c) 2019 Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build (!amd64 && !arm64) || appengine || !gc || noasm
+// +build !amd64,!arm64 appengine !gc noasm
+
+package s2
+
+import (
+        "fmt"
+        "strconv"
+)
+
+// decode writes the decoding of src to dst. It assumes that the varint-encoded
+// length of the decompressed bytes has already been read, and that len(dst)
+// equals that length.
+//
+// It returns 0 on success or a decodeErrCodeXxx error code on failure.
+func s2Decode(dst, src []byte) int {
+        const debug = false
+        if debug {
+                fmt.Println("Starting decode, dst len:", len(dst))
+        }
+        var d, s, length int
+        offset := 0
+
+        // As long as we can read at least 5 bytes...
+        for s < len(src)-5 {
+                // Removing bounds checks is SLOWER, when if doing
+                // in := src[s:s+5]
+                // Checked on Go 1.18
+                switch src[s] & 0x03 {
+                case tagLiteral:
+                        x := uint32(src[s] >> 2)
+                        switch {
+                        case x < 60:
+                                s++
+                        case x == 60:
+                                s += 2
+                                x = uint32(src[s-1])
+                        case x == 61:
+                                in := src[s : s+3]
+                                x = uint32(in[1]) | uint32(in[2])<<8
+                                s += 3
+                        case x == 62:
+                                in := src[s : s+4]
+                                // Load as 32 bit and shift down.
+                                x = uint32(in[0]) | uint32(in[1])<<8 | uint32(in[2])<<16 | uint32(in[3])<<24
+                                x >>= 8
+                                s += 4
+                        case x == 63:
+                                in := src[s : s+5]
+                                x = uint32(in[1]) | uint32(in[2])<<8 | uint32(in[3])<<16 | uint32(in[4])<<24
+                                s += 5
+                        }
+                        length = int(x) + 1
+                        if length > len(dst)-d || length > len(src)-s || (strconv.IntSize == 32 && length <= 0) {
+                                if debug {
+                                        fmt.Println("corrupt: lit size", length)
+                                }
+                                return decodeErrCodeCorrupt
+                        }
+                        if debug {
+                                fmt.Println("literals, length:", length, "d-after:", d+length)
+                        }
+
+                        copy(dst[d:], src[s:s+length])
+                        d += length
+                        s += length
+                        continue
+
+                case tagCopy1:
+                        s += 2
+                        toffset := int(uint32(src[s-2])&0xe0<<3 | uint32(src[s-1]))
+                        length = int(src[s-2]) >> 2 & 0x7
+                        if toffset == 0 {
+                                if debug {
+                                        fmt.Print("(repeat) ")
+                                }
+                                // keep last offset
+                                switch length {
+                                case 5:
+                                        length = int(src[s]) + 4
+                                        s += 1
+                                case 6:
+                                        in := src[s : s+2]
+                                        length = int(uint32(in[0])|(uint32(in[1])<<8)) + (1 << 8)
+                                        s += 2
+                                case 7:
+                                        in := src[s : s+3]
+                                        length = int((uint32(in[2])<<16)|(uint32(in[1])<<8)|uint32(in[0])) + (1 << 16)
+                                        s += 3
+                                default: // 0-> 4
+                                }
+                        } else {
+                                offset = toffset
+                        }
+                        length += 4
+                case tagCopy2:
+                        in := src[s : s+3]
+                        offset = int(uint32(in[1]) | uint32(in[2])<<8)
+                        length = 1 + int(in[0])>>2
+                        s += 3
+
+                case tagCopy4:
+                        in := src[s : s+5]
+                        offset = int(uint32(in[1]) | uint32(in[2])<<8 | uint32(in[3])<<16 | uint32(in[4])<<24)
+                        length = 1 + int(in[0])>>2
+                        s += 5
+                }
+
+                if offset <= 0 || d < offset || length > len(dst)-d {
+                        if debug {
+                                fmt.Println("corrupt: match, length", length, "offset:", offset, "dst avail:", len(dst)-d, "dst pos:", d)
+                        }
+
+                        return decodeErrCodeCorrupt
+                }
+
+                if debug {
+                        fmt.Println("copy, length:", length, "offset:", offset, "d-after:", d+length)
+                }
+
+                // Copy from an earlier sub-slice of dst to a later sub-slice.
+                // If no overlap, use the built-in copy:
+                if offset > length {
+                        copy(dst[d:d+length], dst[d-offset:])
+                        d += length
+                        continue
+                }
+
+                // Unlike the built-in copy function, this byte-by-byte copy always runs
+                // forwards, even if the slices overlap. Conceptually, this is:
+                //
+                // d += forwardCopy(dst[d:d+length], dst[d-offset:])
+                //
+                // We align the slices into a and b and show the compiler they are the same size.
+                // This allows the loop to run without bounds checks.
+                a := dst[d : d+length]
+                b := dst[d-offset:]
+                b = b[:len(a)]
+                for i := range a {
+                        a[i] = b[i]
+                }
+                d += length
+        }
+
+        // Remaining with extra checks...
+        for s < len(src) {
+                switch src[s] & 0x03 {
+                case tagLiteral:
+                        x := uint32(src[s] >> 2)
+                        switch {
+                        case x < 60:
+                                s++
+                        case x == 60:
+                                s += 2
+                                if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                        return decodeErrCodeCorrupt
+                                }
+                                x = uint32(src[s-1])
+                        case x == 61:
+                                s += 3
+                                if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                        return decodeErrCodeCorrupt
+                                }
+                                x = uint32(src[s-2]) | uint32(src[s-1])<<8
+                        case x == 62:
+                                s += 4
+                                if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                        return decodeErrCodeCorrupt
+                                }
+                                x = uint32(src[s-3]) | uint32(src[s-2])<<8 | uint32(src[s-1])<<16
+                        case x == 63:
+                                s += 5
+                                if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                        return decodeErrCodeCorrupt
+                                }
+                                x = uint32(src[s-4]) | uint32(src[s-3])<<8 | uint32(src[s-2])<<16 | uint32(src[s-1])<<24
+                        }
+                        length = int(x) + 1
+                        if length > len(dst)-d || length > len(src)-s || (strconv.IntSize == 32 && length <= 0) {
+                                if debug {
+                                        fmt.Println("corrupt: lit size", length)
+                                }
+                                return decodeErrCodeCorrupt
+                        }
+                        if debug {
+                                fmt.Println("literals, length:", length, "d-after:", d+length)
+                        }
+
+                        copy(dst[d:], src[s:s+length])
+                        d += length
+                        s += length
+                        continue
+
+                case tagCopy1:
+                        s += 2
+                        if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                return decodeErrCodeCorrupt
+                        }
+                        length = int(src[s-2]) >> 2 & 0x7
+                        toffset := int(uint32(src[s-2])&0xe0<<3 | uint32(src[s-1]))
+                        if toffset == 0 {
+                                if debug {
+                                        fmt.Print("(repeat) ")
+                                }
+                                // keep last offset
+                                switch length {
+                                case 5:
+                                        s += 1
+                                        if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                                return decodeErrCodeCorrupt
+                                        }
+                                        length = int(uint32(src[s-1])) + 4
+                                case 6:
+                                        s += 2
+                                        if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                                return decodeErrCodeCorrupt
+                                        }
+                                        length = int(uint32(src[s-2])|(uint32(src[s-1])<<8)) + (1 << 8)
+                                case 7:
+                                        s += 3
+                                        if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                                return decodeErrCodeCorrupt
+                                        }
+                                        length = int(uint32(src[s-3])|(uint32(src[s-2])<<8)|(uint32(src[s-1])<<16)) + (1 << 16)
+                                default: // 0-> 4
+                                }
+                        } else {
+                                offset = toffset
+                        }
+                        length += 4
+                case tagCopy2:
+                        s += 3
+                        if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                return decodeErrCodeCorrupt
+                        }
+                        length = 1 + int(src[s-3])>>2
+                        offset = int(uint32(src[s-2]) | uint32(src[s-1])<<8)
+
+                case tagCopy4:
+                        s += 5
+                        if uint(s) > uint(len(src)) { // The uint conversions catch overflow from the previous line.
+                                return decodeErrCodeCorrupt
+                        }
+                        length = 1 + int(src[s-5])>>2
+                        offset = int(uint32(src[s-4]) | uint32(src[s-3])<<8 | uint32(src[s-2])<<16 | uint32(src[s-1])<<24)
+                }
+
+                if offset <= 0 || d < offset || length > len(dst)-d {
+                        if debug {
+                                fmt.Println("corrupt: match, length", length, "offset:", offset, "dst avail:", len(dst)-d, "dst pos:", d)
+                        }
+                        return decodeErrCodeCorrupt
+                }
+
+                if debug {
+                        fmt.Println("copy, length:", length, "offset:", offset, "d-after:", d+length)
+                }
+
+                // Copy from an earlier sub-slice of dst to a later sub-slice.
+                // If no overlap, use the built-in copy:
+                if offset > length {
+                        copy(dst[d:d+length], dst[d-offset:])
+                        d += length
+                        continue
+                }
+
+                // Unlike the built-in copy function, this byte-by-byte copy always runs
+                // forwards, even if the slices overlap. Conceptually, this is:
+                //
+                // d += forwardCopy(dst[d:d+length], dst[d-offset:])
+                //
+                // We align the slices into a and b and show the compiler they are the same size.
+                // This allows the loop to run without bounds checks.
+                a := dst[d : d+length]
+                b := dst[d-offset:]
+                b = b[:len(a)]
+                for i := range a {
+                        a[i] = b[i]
+                }
+                d += length
+        }
+
+        if d != len(dst) {
+                return decodeErrCodeCorrupt
+        }
+        return 0
+}
diff --git a/vendor/github.com/klauspost/compress/s2/dict.go b/vendor/github.com/klauspost/compress/s2/dict.go
new file mode 100644
index 0000000..f125ad0
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/dict.go
@@ -0,0 +1,350 @@
+// Copyright (c) 2022+ Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s2
+
+import (
+        "bytes"
+        "encoding/binary"
+        "sync"
+)
+
+const (
+        // MinDictSize is the minimum dictionary size when repeat has been read.
+        MinDictSize = 16
+
+        // MaxDictSize is the maximum dictionary size when repeat has been read.
+        MaxDictSize = 65536
+
+        // MaxDictSrcOffset is the maximum offset where a dictionary entry can start.
+        MaxDictSrcOffset = 65535
+)
+
+// Dict contains a dictionary that can be used for encoding and decoding s2
+type Dict struct {
+        dict   []byte
+        repeat int // Repeat as index of dict
+
+        fast, better, best sync.Once
+        fastTable          *[1 << 14]uint16
+
+        betterTableShort *[1 << 14]uint16
+        betterTableLong  *[1 << 17]uint16
+
+        bestTableShort *[1 << 16]uint32
+        bestTableLong  *[1 << 19]uint32
+}
+
+// NewDict will read a dictionary.
+// It will return nil if the dictionary is invalid.
+func NewDict(dict []byte) *Dict {
+        if len(dict) == 0 {
+                return nil
+        }
+        var d Dict
+        // Repeat is the first value of the dict
+        r, n := binary.Uvarint(dict)
+        if n <= 0 {
+                return nil
+        }
+        dict = dict[n:]
+        d.dict = dict
+        if cap(d.dict) < len(d.dict)+16 {
+                d.dict = append(make([]byte, 0, len(d.dict)+16), d.dict...)
+        }
+        if len(dict) < MinDictSize || len(dict) > MaxDictSize {
+                return nil
+        }
+        d.repeat = int(r)
+        if d.repeat > len(dict) {
+                return nil
+        }
+        return &d
+}
+
+// Bytes will return a serialized version of the dictionary.
+// The output can be sent to NewDict.
+func (d *Dict) Bytes() []byte {
+        dst := make([]byte, binary.MaxVarintLen16+len(d.dict))
+        return append(dst[:binary.PutUvarint(dst, uint64(d.repeat))], d.dict...)
+}
+
+// MakeDict will create a dictionary.
+// 'data' must be at least MinDictSize.
+// If data is longer than MaxDictSize only the last MaxDictSize bytes will be used.
+// If searchStart is set the start repeat value will be set to the last
+// match of this content.
+// If no matches are found, it will attempt to find shorter matches.
+// This content should match the typical start of a block.
+// If at least 4 bytes cannot be matched, repeat is set to start of block.
+func MakeDict(data []byte, searchStart []byte) *Dict {
+        if len(data) == 0 {
+                return nil
+        }
+        if len(data) > MaxDictSize {
+                data = data[len(data)-MaxDictSize:]
+        }
+        var d Dict
+        dict := data
+        d.dict = dict
+        if cap(d.dict) < len(d.dict)+16 {
+                d.dict = append(make([]byte, 0, len(d.dict)+16), d.dict...)
+        }
+        if len(dict) < MinDictSize {
+                return nil
+        }
+
+        // Find the longest match possible, last entry if multiple.
+        for s := len(searchStart); s > 4; s-- {
+                if idx := bytes.LastIndex(data, searchStart[:s]); idx >= 0 && idx <= len(data)-8 {
+                        d.repeat = idx
+                        break
+                }
+        }
+
+        return &d
+}
+
+// MakeDictManual will create a dictionary.
+// 'data' must be at least MinDictSize and less than or equal to MaxDictSize.
+// A manual first repeat index into data must be provided.
+// It must be less than len(data)-8.
+func MakeDictManual(data []byte, firstIdx uint16) *Dict {
+        if len(data) < MinDictSize || int(firstIdx) >= len(data)-8 || len(data) > MaxDictSize {
+                return nil
+        }
+        var d Dict
+        dict := data
+        d.dict = dict
+        if cap(d.dict) < len(d.dict)+16 {
+                d.dict = append(make([]byte, 0, len(d.dict)+16), d.dict...)
+        }
+
+        d.repeat = int(firstIdx)
+        return &d
+}
+
+// Encode returns the encoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire encoded block.
+// Otherwise, a newly allocated slice will be returned.
+//
+// The dst and src must not overlap. It is valid to pass a nil dst.
+//
+// The blocks will require the same amount of memory to decode as encoding,
+// and does not make for concurrent decoding.
+// Also note that blocks do not contain CRC information, so corruption may be undetected.
+//
+// If you need to encode larger amounts of data, consider using
+// the streaming interface which gives all of these features.
+func (d *Dict) Encode(dst, src []byte) []byte {
+        if n := MaxEncodedLen(len(src)); n < 0 {
+                panic(ErrTooLarge)
+        } else if cap(dst) < n {
+                dst = make([]byte, n)
+        } else {
+                dst = dst[:n]
+        }
+
+        // The block starts with the varint-encoded length of the decompressed bytes.
+        dstP := binary.PutUvarint(dst, uint64(len(src)))
+
+        if len(src) == 0 {
+                return dst[:dstP]
+        }
+        if len(src) < minNonLiteralBlockSize {
+                dstP += emitLiteral(dst[dstP:], src)
+                return dst[:dstP]
+        }
+        n := encodeBlockDictGo(dst[dstP:], src, d)
+        if n > 0 {
+                dstP += n
+                return dst[:dstP]
+        }
+        // Not compressible
+        dstP += emitLiteral(dst[dstP:], src)
+        return dst[:dstP]
+}
+
+// EncodeBetter returns the encoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire encoded block.
+// Otherwise, a newly allocated slice will be returned.
+//
+// EncodeBetter compresses better than Encode but typically with a
+// 10-40% speed decrease on both compression and decompression.
+//
+// The dst and src must not overlap. It is valid to pass a nil dst.
+//
+// The blocks will require the same amount of memory to decode as encoding,
+// and does not make for concurrent decoding.
+// Also note that blocks do not contain CRC information, so corruption may be undetected.
+//
+// If you need to encode larger amounts of data, consider using
+// the streaming interface which gives all of these features.
+func (d *Dict) EncodeBetter(dst, src []byte) []byte {
+        if n := MaxEncodedLen(len(src)); n < 0 {
+                panic(ErrTooLarge)
+        } else if len(dst) < n {
+                dst = make([]byte, n)
+        }
+
+        // The block starts with the varint-encoded length of the decompressed bytes.
+        dstP := binary.PutUvarint(dst, uint64(len(src)))
+
+        if len(src) == 0 {
+                return dst[:dstP]
+        }
+        if len(src) < minNonLiteralBlockSize {
+                dstP += emitLiteral(dst[dstP:], src)
+                return dst[:dstP]
+        }
+        n := encodeBlockBetterDict(dst[dstP:], src, d)
+        if n > 0 {
+                dstP += n
+                return dst[:dstP]
+        }
+        // Not compressible
+        dstP += emitLiteral(dst[dstP:], src)
+        return dst[:dstP]
+}
+
+// EncodeBest returns the encoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire encoded block.
+// Otherwise, a newly allocated slice will be returned.
+//
+// EncodeBest compresses as good as reasonably possible but with a
+// big speed decrease.
+//
+// The dst and src must not overlap. It is valid to pass a nil dst.
+//
+// The blocks will require the same amount of memory to decode as encoding,
+// and does not make for concurrent decoding.
+// Also note that blocks do not contain CRC information, so corruption may be undetected.
+//
+// If you need to encode larger amounts of data, consider using
+// the streaming interface which gives all of these features.
+func (d *Dict) EncodeBest(dst, src []byte) []byte {
+        if n := MaxEncodedLen(len(src)); n < 0 {
+                panic(ErrTooLarge)
+        } else if len(dst) < n {
+                dst = make([]byte, n)
+        }
+
+        // The block starts with the varint-encoded length of the decompressed bytes.
+        dstP := binary.PutUvarint(dst, uint64(len(src)))
+
+        if len(src) == 0 {
+                return dst[:dstP]
+        }
+        if len(src) < minNonLiteralBlockSize {
+                dstP += emitLiteral(dst[dstP:], src)
+                return dst[:dstP]
+        }
+        n := encodeBlockBest(dst[dstP:], src, d)
+        if n > 0 {
+                dstP += n
+                return dst[:dstP]
+        }
+        // Not compressible
+        dstP += emitLiteral(dst[dstP:], src)
+        return dst[:dstP]
+}
+
+// Decode returns the decoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire decoded block.
+// Otherwise, a newly allocated slice will be returned.
+//
+// The dst and src must not overlap. It is valid to pass a nil dst.
+func (d *Dict) Decode(dst, src []byte) ([]byte, error) {
+        dLen, s, err := decodedLen(src)
+        if err != nil {
+                return nil, err
+        }
+        if dLen <= cap(dst) {
+                dst = dst[:dLen]
+        } else {
+                dst = make([]byte, dLen)
+        }
+        if s2DecodeDict(dst, src[s:], d) != 0 {
+                return nil, ErrCorrupt
+        }
+        return dst, nil
+}
+
+func (d *Dict) initFast() {
+        d.fast.Do(func() {
+                const (
+                        tableBits    = 14
+                        maxTableSize = 1 << tableBits
+                )
+
+                var table [maxTableSize]uint16
+                // We stop so any entry of length 8 can always be read.
+                for i := 0; i < len(d.dict)-8-2; i += 3 {
+                        x0 := load64(d.dict, i)
+                        h0 := hash6(x0, tableBits)
+                        h1 := hash6(x0>>8, tableBits)
+                        h2 := hash6(x0>>16, tableBits)
+                        table[h0] = uint16(i)
+                        table[h1] = uint16(i + 1)
+                        table[h2] = uint16(i + 2)
+                }
+                d.fastTable = &table
+        })
+}
+
+func (d *Dict) initBetter() {
+        d.better.Do(func() {
+                const (
+                        // Long hash matches.
+                        lTableBits    = 17
+                        maxLTableSize = 1 << lTableBits
+
+                        // Short hash matches.
+                        sTableBits    = 14
+                        maxSTableSize = 1 << sTableBits
+                )
+
+                var lTable [maxLTableSize]uint16
+                var sTable [maxSTableSize]uint16
+
+                // We stop so any entry of length 8 can always be read.
+                for i := 0; i < len(d.dict)-8; i++ {
+                        cv := load64(d.dict, i)
+                        lTable[hash7(cv, lTableBits)] = uint16(i)
+                        sTable[hash4(cv, sTableBits)] = uint16(i)
+                }
+                d.betterTableShort = &sTable
+                d.betterTableLong = &lTable
+        })
+}
+
+func (d *Dict) initBest() {
+        d.best.Do(func() {
+                const (
+                        // Long hash matches.
+                        lTableBits    = 19
+                        maxLTableSize = 1 << lTableBits
+
+                        // Short hash matches.
+                        sTableBits    = 16
+                        maxSTableSize = 1 << sTableBits
+                )
+
+                var lTable [maxLTableSize]uint32
+                var sTable [maxSTableSize]uint32
+
+                // We stop so any entry of length 8 can always be read.
+                for i := 0; i < len(d.dict)-8; i++ {
+                        cv := load64(d.dict, i)
+                        hashL := hash8(cv, lTableBits)
+                        hashS := hash4(cv, sTableBits)
+                        candidateL := lTable[hashL]
+                        candidateS := sTable[hashS]
+                        lTable[hashL] = uint32(i) | candidateL<<16
+                        sTable[hashS] = uint32(i) | candidateS<<16
+                }
+                d.bestTableShort = &sTable
+                d.bestTableLong = &lTable
+        })
+}
diff --git a/vendor/github.com/klauspost/compress/s2/encode.go b/vendor/github.com/klauspost/compress/s2/encode.go
new file mode 100644
index 0000000..0c9088a
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/encode.go
@@ -0,0 +1,393 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Copyright (c) 2019 Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s2
+
+import (
+        "encoding/binary"
+        "math"
+        "math/bits"
+)
+
+// Encode returns the encoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire encoded block.
+// Otherwise, a newly allocated slice will be returned.
+//
+// The dst and src must not overlap. It is valid to pass a nil dst.
+//
+// The blocks will require the same amount of memory to decode as encoding,
+// and does not make for concurrent decoding.
+// Also note that blocks do not contain CRC information, so corruption may be undetected.
+//
+// If you need to encode larger amounts of data, consider using
+// the streaming interface which gives all of these features.
+func Encode(dst, src []byte) []byte {
+        if n := MaxEncodedLen(len(src)); n < 0 {
+                panic(ErrTooLarge)
+        } else if cap(dst) < n {
+                dst = make([]byte, n)
+        } else {
+                dst = dst[:n]
+        }
+
+        // The block starts with the varint-encoded length of the decompressed bytes.
+        d := binary.PutUvarint(dst, uint64(len(src)))
+
+        if len(src) == 0 {
+                return dst[:d]
+        }
+        if len(src) < minNonLiteralBlockSize {
+                d += emitLiteral(dst[d:], src)
+                return dst[:d]
+        }
+        n := encodeBlock(dst[d:], src)
+        if n > 0 {
+                d += n
+                return dst[:d]
+        }
+        // Not compressible
+        d += emitLiteral(dst[d:], src)
+        return dst[:d]
+}
+
+// EstimateBlockSize will perform a very fast compression
+// without outputting the result and return the compressed output size.
+// The function returns -1 if no improvement could be achieved.
+// Using actual compression will most often produce better compression than the estimate.
+func EstimateBlockSize(src []byte) (d int) {
+        if len(src) <= inputMargin || int64(len(src)) > 0xffffffff {
+                return -1
+        }
+        if len(src) <= 1024 {
+                d = calcBlockSizeSmall(src)
+        } else {
+                d = calcBlockSize(src)
+        }
+
+        if d == 0 {
+                return -1
+        }
+        // Size of the varint encoded block size.
+        d += (bits.Len64(uint64(len(src))) + 7) / 7
+
+        if d >= len(src) {
+                return -1
+        }
+        return d
+}
+
+// EncodeBetter returns the encoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire encoded block.
+// Otherwise, a newly allocated slice will be returned.
+//
+// EncodeBetter compresses better than Encode but typically with a
+// 10-40% speed decrease on both compression and decompression.
+//
+// The dst and src must not overlap. It is valid to pass a nil dst.
+//
+// The blocks will require the same amount of memory to decode as encoding,
+// and does not make for concurrent decoding.
+// Also note that blocks do not contain CRC information, so corruption may be undetected.
+//
+// If you need to encode larger amounts of data, consider using
+// the streaming interface which gives all of these features.
+func EncodeBetter(dst, src []byte) []byte {
+        if n := MaxEncodedLen(len(src)); n < 0 {
+                panic(ErrTooLarge)
+        } else if len(dst) < n {
+                dst = make([]byte, n)
+        }
+
+        // The block starts with the varint-encoded length of the decompressed bytes.
+        d := binary.PutUvarint(dst, uint64(len(src)))
+
+        if len(src) == 0 {
+                return dst[:d]
+        }
+        if len(src) < minNonLiteralBlockSize {
+                d += emitLiteral(dst[d:], src)
+                return dst[:d]
+        }
+        n := encodeBlockBetter(dst[d:], src)
+        if n > 0 {
+                d += n
+                return dst[:d]
+        }
+        // Not compressible
+        d += emitLiteral(dst[d:], src)
+        return dst[:d]
+}
+
+// EncodeBest returns the encoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire encoded block.
+// Otherwise, a newly allocated slice will be returned.
+//
+// EncodeBest compresses as good as reasonably possible but with a
+// big speed decrease.
+//
+// The dst and src must not overlap. It is valid to pass a nil dst.
+//
+// The blocks will require the same amount of memory to decode as encoding,
+// and does not make for concurrent decoding.
+// Also note that blocks do not contain CRC information, so corruption may be undetected.
+//
+// If you need to encode larger amounts of data, consider using
+// the streaming interface which gives all of these features.
+func EncodeBest(dst, src []byte) []byte {
+        if n := MaxEncodedLen(len(src)); n < 0 {
+                panic(ErrTooLarge)
+        } else if len(dst) < n {
+                dst = make([]byte, n)
+        }
+
+        // The block starts with the varint-encoded length of the decompressed bytes.
+        d := binary.PutUvarint(dst, uint64(len(src)))
+
+        if len(src) == 0 {
+                return dst[:d]
+        }
+        if len(src) < minNonLiteralBlockSize {
+                d += emitLiteral(dst[d:], src)
+                return dst[:d]
+        }
+        n := encodeBlockBest(dst[d:], src, nil)
+        if n > 0 {
+                d += n
+                return dst[:d]
+        }
+        // Not compressible
+        d += emitLiteral(dst[d:], src)
+        return dst[:d]
+}
+
+// EncodeSnappy returns the encoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire encoded block.
+// Otherwise, a newly allocated slice will be returned.
+//
+// The output is Snappy compatible and will likely decompress faster.
+//
+// The dst and src must not overlap. It is valid to pass a nil dst.
+//
+// The blocks will require the same amount of memory to decode as encoding,
+// and does not make for concurrent decoding.
+// Also note that blocks do not contain CRC information, so corruption may be undetected.
+//
+// If you need to encode larger amounts of data, consider using
+// the streaming interface which gives all of these features.
+func EncodeSnappy(dst, src []byte) []byte {
+        if n := MaxEncodedLen(len(src)); n < 0 {
+                panic(ErrTooLarge)
+        } else if cap(dst) < n {
+                dst = make([]byte, n)
+        } else {
+                dst = dst[:n]
+        }
+
+        // The block starts with the varint-encoded length of the decompressed bytes.
+        d := binary.PutUvarint(dst, uint64(len(src)))
+
+        if len(src) == 0 {
+                return dst[:d]
+        }
+        if len(src) < minNonLiteralBlockSize {
+                d += emitLiteral(dst[d:], src)
+                return dst[:d]
+        }
+
+        n := encodeBlockSnappy(dst[d:], src)
+        if n > 0 {
+                d += n
+                return dst[:d]
+        }
+        // Not compressible
+        d += emitLiteral(dst[d:], src)
+        return dst[:d]
+}
+
+// EncodeSnappyBetter returns the encoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire encoded block.
+// Otherwise, a newly allocated slice will be returned.
+//
+// The output is Snappy compatible and will likely decompress faster.
+//
+// The dst and src must not overlap. It is valid to pass a nil dst.
+//
+// The blocks will require the same amount of memory to decode as encoding,
+// and does not make for concurrent decoding.
+// Also note that blocks do not contain CRC information, so corruption may be undetected.
+//
+// If you need to encode larger amounts of data, consider using
+// the streaming interface which gives all of these features.
+func EncodeSnappyBetter(dst, src []byte) []byte {
+        if n := MaxEncodedLen(len(src)); n < 0 {
+                panic(ErrTooLarge)
+        } else if cap(dst) < n {
+                dst = make([]byte, n)
+        } else {
+                dst = dst[:n]
+        }
+
+        // The block starts with the varint-encoded length of the decompressed bytes.
+        d := binary.PutUvarint(dst, uint64(len(src)))
+
+        if len(src) == 0 {
+                return dst[:d]
+        }
+        if len(src) < minNonLiteralBlockSize {
+                d += emitLiteral(dst[d:], src)
+                return dst[:d]
+        }
+
+        n := encodeBlockBetterSnappy(dst[d:], src)
+        if n > 0 {
+                d += n
+                return dst[:d]
+        }
+        // Not compressible
+        d += emitLiteral(dst[d:], src)
+        return dst[:d]
+}
+
+// EncodeSnappyBest returns the encoded form of src. The returned slice may be a sub-
+// slice of dst if dst was large enough to hold the entire encoded block.
+// Otherwise, a newly allocated slice will be returned.
+//
+// The output is Snappy compatible and will likely decompress faster.
+//
+// The dst and src must not overlap. It is valid to pass a nil dst.
+//
+// The blocks will require the same amount of memory to decode as encoding,
+// and does not make for concurrent decoding.
+// Also note that blocks do not contain CRC information, so corruption may be undetected.
+//
+// If you need to encode larger amounts of data, consider using
+// the streaming interface which gives all of these features.
+func EncodeSnappyBest(dst, src []byte) []byte {
+        if n := MaxEncodedLen(len(src)); n < 0 {
+                panic(ErrTooLarge)
+        } else if cap(dst) < n {
+                dst = make([]byte, n)
+        } else {
+                dst = dst[:n]
+        }
+
+        // The block starts with the varint-encoded length of the decompressed bytes.
+        d := binary.PutUvarint(dst, uint64(len(src)))
+
+        if len(src) == 0 {
+                return dst[:d]
+        }
+        if len(src) < minNonLiteralBlockSize {
+                d += emitLiteral(dst[d:], src)
+                return dst[:d]
+        }
+
+        n := encodeBlockBestSnappy(dst[d:], src)
+        if n > 0 {
+                d += n
+                return dst[:d]
+        }
+        // Not compressible
+        d += emitLiteral(dst[d:], src)
+        return dst[:d]
+}
+
+// ConcatBlocks will concatenate the supplied blocks and append them to the supplied destination.
+// If the destination is nil or too small, a new will be allocated.
+// The blocks are not validated, so garbage in = garbage out.
+// dst may not overlap block data.
+// Any data in dst is preserved as is, so it will not be considered a block.
+func ConcatBlocks(dst []byte, blocks ...[]byte) ([]byte, error) {
+        totalSize := uint64(0)
+        compSize := 0
+        for _, b := range blocks {
+                l, hdr, err := decodedLen(b)
+                if err != nil {
+                        return nil, err
+                }
+                totalSize += uint64(l)
+                compSize += len(b) - hdr
+        }
+        if totalSize == 0 {
+                dst = append(dst, 0)
+                return dst, nil
+        }
+        if totalSize > math.MaxUint32 {
+                return nil, ErrTooLarge
+        }
+        var tmp [binary.MaxVarintLen32]byte
+        hdrSize := binary.PutUvarint(tmp[:], totalSize)
+        wantSize := hdrSize + compSize
+
+        if cap(dst)-len(dst) < wantSize {
+                dst = append(make([]byte, 0, wantSize+len(dst)), dst...)
+        }
+        dst = append(dst, tmp[:hdrSize]...)
+        for _, b := range blocks {
+                _, hdr, err := decodedLen(b)
+                if err != nil {
+                        return nil, err
+                }
+                dst = append(dst, b[hdr:]...)
+        }
+        return dst, nil
+}
+
+// inputMargin is the minimum number of extra input bytes to keep, inside
+// encodeBlock's inner loop. On some architectures, this margin lets us
+// implement a fast path for emitLiteral, where the copy of short (<= 16 byte)
+// literals can be implemented as a single load to and store from a 16-byte
+// register. That literal's actual length can be as short as 1 byte, so this
+// can copy up to 15 bytes too much, but that's OK as subsequent iterations of
+// the encoding loop will fix up the copy overrun, and this inputMargin ensures
+// that we don't overrun the dst and src buffers.
+const inputMargin = 8
+
+// minNonLiteralBlockSize is the minimum size of the input to encodeBlock that
+// will be accepted by the encoder.
+const minNonLiteralBlockSize = 32
+
+const intReduction = 2 - (1 << (^uint(0) >> 63)) // 1 (32 bits) or 0 (64 bits)
+
+// MaxBlockSize is the maximum value where MaxEncodedLen will return a valid block size.
+// Blocks this big are highly discouraged, though.
+// Half the size on 32 bit systems.
+const MaxBlockSize = (1<<(32-intReduction) - 1) - binary.MaxVarintLen32 - 5
+
+// MaxEncodedLen returns the maximum length of a snappy block, given its
+// uncompressed length.
+//
+// It will return a negative value if srcLen is too large to encode.
+// 32 bit platforms will have lower thresholds for rejecting big content.
+func MaxEncodedLen(srcLen int) int {
+        n := uint64(srcLen)
+        if intReduction == 1 {
+                // 32 bits
+                if n > math.MaxInt32 {
+                        // Also includes negative.
+                        return -1
+                }
+        } else if n > 0xffffffff {
+                // 64 bits
+                // Also includes negative.
+                return -1
+        }
+        // Size of the varint encoded block size.
+        n = n + uint64((bits.Len64(n)+7)/7)
+
+        // Add maximum size of encoding block as literals.
+        n += uint64(literalExtraSize(int64(srcLen)))
+        if intReduction == 1 {
+                // 32 bits
+                if n > math.MaxInt32 {
+                        return -1
+                }
+        } else if n > 0xffffffff {
+                // 64 bits
+                // Also includes negative.
+                return -1
+        }
+        return int(n)
+}
diff --git a/vendor/github.com/klauspost/compress/s2/encode_all.go b/vendor/github.com/klauspost/compress/s2/encode_all.go
new file mode 100644
index 0000000..5e57995
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/encode_all.go
@@ -0,0 +1,1048 @@
+// Copyright 2016 The Snappy-Go Authors. All rights reserved.
+// Copyright (c) 2019 Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s2
+
+import (
+        "bytes"
+        "encoding/binary"
+        "fmt"
+        "math/bits"
+)
+
+func load32(b []byte, i int) uint32 {
+        return binary.LittleEndian.Uint32(b[i:])
+}
+
+func load64(b []byte, i int) uint64 {
+        return binary.LittleEndian.Uint64(b[i:])
+}
+
+// hash6 returns the hash of the lowest 6 bytes of u to fit in a hash table with h bits.
+// Preferably h should be a constant and should always be <64.
+func hash6(u uint64, h uint8) uint32 {
+        const prime6bytes = 227718039650203
+        return uint32(((u << (64 - 48)) * prime6bytes) >> ((64 - h) & 63))
+}
+
+func encodeGo(dst, src []byte) []byte {
+        if n := MaxEncodedLen(len(src)); n < 0 {
+                panic(ErrTooLarge)
+        } else if len(dst) < n {
+                dst = make([]byte, n)
+        }
+
+        // The block starts with the varint-encoded length of the decompressed bytes.
+        d := binary.PutUvarint(dst, uint64(len(src)))
+
+        if len(src) == 0 {
+                return dst[:d]
+        }
+        if len(src) < minNonLiteralBlockSize {
+                d += emitLiteral(dst[d:], src)
+                return dst[:d]
+        }
+        n := encodeBlockGo(dst[d:], src)
+        if n > 0 {
+                d += n
+                return dst[:d]
+        }
+        // Not compressible
+        d += emitLiteral(dst[d:], src)
+        return dst[:d]
+}
+
+// encodeBlockGo encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src)) &&
+//      minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
+func encodeBlockGo(dst, src []byte) (d int) {
+        // Initialize the hash table.
+        const (
+                tableBits    = 14
+                maxTableSize = 1 << tableBits
+
+                debug = false
+        )
+
+        var table [maxTableSize]uint32
+
+        // sLimit is when to stop looking for offset/length copies. The inputMargin
+        // lets us use a fast path for emitLiteral in the main loop, while we are
+        // looking for copies.
+        sLimit := len(src) - inputMargin
+
+        // Bail if we can't compress to at least this.
+        dstLimit := len(src) - len(src)>>5 - 5
+
+        // nextEmit is where in src the next emitLiteral should start from.
+        nextEmit := 0
+
+        // The encoded form must start with a literal, as there are no previous
+        // bytes to copy, so we start looking for hash matches at s == 1.
+        s := 1
+        cv := load64(src, s)
+
+        // We search for a repeat at -1, but don't output repeats when nextEmit == 0
+        repeat := 1
+
+        for {
+                candidate := 0
+                for {
+                        // Next src position to check
+                        nextS := s + (s-nextEmit)>>6 + 4
+                        if nextS > sLimit {
+                                goto emitRemainder
+                        }
+                        hash0 := hash6(cv, tableBits)
+                        hash1 := hash6(cv>>8, tableBits)
+                        candidate = int(table[hash0])
+                        candidate2 := int(table[hash1])
+                        table[hash0] = uint32(s)
+                        table[hash1] = uint32(s + 1)
+                        hash2 := hash6(cv>>16, tableBits)
+
+                        // Check repeat at offset checkRep.
+                        const checkRep = 1
+                        if uint32(cv>>(checkRep*8)) == load32(src, s-repeat+checkRep) {
+                                base := s + checkRep
+                                // Extend back
+                                for i := base - repeat; base > nextEmit && i > 0 && src[i-1] == src[base-1]; {
+                                        i--
+                                        base--
+                                }
+                                d += emitLiteral(dst[d:], src[nextEmit:base])
+
+                                // Extend forward
+                                candidate := s - repeat + 4 + checkRep
+                                s += 4 + checkRep
+                                for s <= sLimit {
+                                        if diff := load64(src, s) ^ load64(src, candidate); diff != 0 {
+                                                s += bits.TrailingZeros64(diff) >> 3
+                                                break
+                                        }
+                                        s += 8
+                                        candidate += 8
+                                }
+                                if debug {
+                                        // Validate match.
+                                        if s <= candidate {
+                                                panic("s <= candidate")
+                                        }
+                                        a := src[base:s]
+                                        b := src[base-repeat : base-repeat+(s-base)]
+                                        if !bytes.Equal(a, b) {
+                                                panic("mismatch")
+                                        }
+                                }
+                                if nextEmit > 0 {
+                                        // same as `add := emitCopy(dst[d:], repeat, s-base)` but skips storing offset.
+                                        d += emitRepeat(dst[d:], repeat, s-base)
+                                } else {
+                                        // First match, cannot be repeat.
+                                        d += emitCopy(dst[d:], repeat, s-base)
+                                }
+                                nextEmit = s
+                                if s >= sLimit {
+                                        goto emitRemainder
+                                }
+
+                                cv = load64(src, s)
+                                continue
+                        }
+
+                        if uint32(cv) == load32(src, candidate) {
+                                break
+                        }
+                        candidate = int(table[hash2])
+                        if uint32(cv>>8) == load32(src, candidate2) {
+                                table[hash2] = uint32(s + 2)
+                                candidate = candidate2
+                                s++
+                                break
+                        }
+                        table[hash2] = uint32(s + 2)
+                        if uint32(cv>>16) == load32(src, candidate) {
+                                s += 2
+                                break
+                        }
+
+                        cv = load64(src, nextS)
+                        s = nextS
+                }
+
+                // Extend backwards.
+                // The top bytes will be rechecked to get the full match.
+                for candidate > 0 && s > nextEmit && src[candidate-1] == src[s-1] {
+                        candidate--
+                        s--
+                }
+
+                // Bail if we exceed the maximum size.
+                if d+(s-nextEmit) > dstLimit {
+                        return 0
+                }
+
+                // A 4-byte match has been found. We'll later see if more than 4 bytes
+                // match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
+                // them as literal bytes.
+
+                d += emitLiteral(dst[d:], src[nextEmit:s])
+
+                // Call emitCopy, and then see if another emitCopy could be our next
+                // move. Repeat until we find no match for the input immediately after
+                // what was consumed by the last emitCopy call.
+                //
+                // If we exit this loop normally then we need to call emitLiteral next,
+                // though we don't yet know how big the literal will be. We handle that
+                // by proceeding to the next iteration of the main loop. We also can
+                // exit this loop via goto if we get close to exhausting the input.
+                for {
+                        // Invariant: we have a 4-byte match at s, and no need to emit any
+                        // literal bytes prior to s.
+                        base := s
+                        repeat = base - candidate
+
+                        // Extend the 4-byte match as long as possible.
+                        s += 4
+                        candidate += 4
+                        for s <= len(src)-8 {
+                                if diff := load64(src, s) ^ load64(src, candidate); diff != 0 {
+                                        s += bits.TrailingZeros64(diff) >> 3
+                                        break
+                                }
+                                s += 8
+                                candidate += 8
+                        }
+
+                        d += emitCopy(dst[d:], repeat, s-base)
+                        if debug {
+                                // Validate match.
+                                if s <= candidate {
+                                        panic("s <= candidate")
+                                }
+                                a := src[base:s]
+                                b := src[base-repeat : base-repeat+(s-base)]
+                                if !bytes.Equal(a, b) {
+                                        panic("mismatch")
+                                }
+                        }
+
+                        nextEmit = s
+                        if s >= sLimit {
+                                goto emitRemainder
+                        }
+
+                        if d > dstLimit {
+                                // Do we have space for more, if not bail.
+                                return 0
+                        }
+                        // Check for an immediate match, otherwise start search at s+1
+                        x := load64(src, s-2)
+                        m2Hash := hash6(x, tableBits)
+                        currHash := hash6(x>>16, tableBits)
+                        candidate = int(table[currHash])
+                        table[m2Hash] = uint32(s - 2)
+                        table[currHash] = uint32(s)
+                        if debug && s == candidate {
+                                panic("s == candidate")
+                        }
+                        if uint32(x>>16) != load32(src, candidate) {
+                                cv = load64(src, s+1)
+                                s++
+                                break
+                        }
+                }
+        }
+
+emitRemainder:
+        if nextEmit < len(src) {
+                // Bail if we exceed the maximum size.
+                if d+len(src)-nextEmit > dstLimit {
+                        return 0
+                }
+                d += emitLiteral(dst[d:], src[nextEmit:])
+        }
+        return d
+}
+
+func encodeBlockSnappyGo(dst, src []byte) (d int) {
+        // Initialize the hash table.
+        const (
+                tableBits    = 14
+                maxTableSize = 1 << tableBits
+        )
+
+        var table [maxTableSize]uint32
+
+        // sLimit is when to stop looking for offset/length copies. The inputMargin
+        // lets us use a fast path for emitLiteral in the main loop, while we are
+        // looking for copies.
+        sLimit := len(src) - inputMargin
+
+        // Bail if we can't compress to at least this.
+        dstLimit := len(src) - len(src)>>5 - 5
+
+        // nextEmit is where in src the next emitLiteral should start from.
+        nextEmit := 0
+
+        // The encoded form must start with a literal, as there are no previous
+        // bytes to copy, so we start looking for hash matches at s == 1.
+        s := 1
+        cv := load64(src, s)
+
+        // We search for a repeat at -1, but don't output repeats when nextEmit == 0
+        repeat := 1
+
+        for {
+                candidate := 0
+                for {
+                        // Next src position to check
+                        nextS := s + (s-nextEmit)>>6 + 4
+                        if nextS > sLimit {
+                                goto emitRemainder
+                        }
+                        hash0 := hash6(cv, tableBits)
+                        hash1 := hash6(cv>>8, tableBits)
+                        candidate = int(table[hash0])
+                        candidate2 := int(table[hash1])
+                        table[hash0] = uint32(s)
+                        table[hash1] = uint32(s + 1)
+                        hash2 := hash6(cv>>16, tableBits)
+
+                        // Check repeat at offset checkRep.
+                        const checkRep = 1
+                        if uint32(cv>>(checkRep*8)) == load32(src, s-repeat+checkRep) {
+                                base := s + checkRep
+                                // Extend back
+                                for i := base - repeat; base > nextEmit && i > 0 && src[i-1] == src[base-1]; {
+                                        i--
+                                        base--
+                                }
+                                d += emitLiteral(dst[d:], src[nextEmit:base])
+
+                                // Extend forward
+                                candidate := s - repeat + 4 + checkRep
+                                s += 4 + checkRep
+                                for s <= sLimit {
+                                        if diff := load64(src, s) ^ load64(src, candidate); diff != 0 {
+                                                s += bits.TrailingZeros64(diff) >> 3
+                                                break
+                                        }
+                                        s += 8
+                                        candidate += 8
+                                }
+
+                                d += emitCopyNoRepeat(dst[d:], repeat, s-base)
+                                nextEmit = s
+                                if s >= sLimit {
+                                        goto emitRemainder
+                                }
+
+                                cv = load64(src, s)
+                                continue
+                        }
+
+                        if uint32(cv) == load32(src, candidate) {
+                                break
+                        }
+                        candidate = int(table[hash2])
+                        if uint32(cv>>8) == load32(src, candidate2) {
+                                table[hash2] = uint32(s + 2)
+                                candidate = candidate2
+                                s++
+                                break
+                        }
+                        table[hash2] = uint32(s + 2)
+                        if uint32(cv>>16) == load32(src, candidate) {
+                                s += 2
+                                break
+                        }
+
+                        cv = load64(src, nextS)
+                        s = nextS
+                }
+
+                // Extend backwards
+                for candidate > 0 && s > nextEmit && src[candidate-1] == src[s-1] {
+                        candidate--
+                        s--
+                }
+
+                // Bail if we exceed the maximum size.
+                if d+(s-nextEmit) > dstLimit {
+                        return 0
+                }
+
+                // A 4-byte match has been found. We'll later see if more than 4 bytes
+                // match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
+                // them as literal bytes.
+
+                d += emitLiteral(dst[d:], src[nextEmit:s])
+
+                // Call emitCopy, and then see if another emitCopy could be our next
+                // move. Repeat until we find no match for the input immediately after
+                // what was consumed by the last emitCopy call.
+                //
+                // If we exit this loop normally then we need to call emitLiteral next,
+                // though we don't yet know how big the literal will be. We handle that
+                // by proceeding to the next iteration of the main loop. We also can
+                // exit this loop via goto if we get close to exhausting the input.
+                for {
+                        // Invariant: we have a 4-byte match at s, and no need to emit any
+                        // literal bytes prior to s.
+                        base := s
+                        repeat = base - candidate
+
+                        // Extend the 4-byte match as long as possible.
+                        s += 4
+                        candidate += 4
+                        for s <= len(src)-8 {
+                                if diff := load64(src, s) ^ load64(src, candidate); diff != 0 {
+                                        s += bits.TrailingZeros64(diff) >> 3
+                                        break
+                                }
+                                s += 8
+                                candidate += 8
+                        }
+
+                        d += emitCopyNoRepeat(dst[d:], repeat, s-base)
+                        if false {
+                                // Validate match.
+                                a := src[base:s]
+                                b := src[base-repeat : base-repeat+(s-base)]
+                                if !bytes.Equal(a, b) {
+                                        panic("mismatch")
+                                }
+                        }
+
+                        nextEmit = s
+                        if s >= sLimit {
+                                goto emitRemainder
+                        }
+
+                        if d > dstLimit {
+                                // Do we have space for more, if not bail.
+                                return 0
+                        }
+                        // Check for an immediate match, otherwise start search at s+1
+                        x := load64(src, s-2)
+                        m2Hash := hash6(x, tableBits)
+                        currHash := hash6(x>>16, tableBits)
+                        candidate = int(table[currHash])
+                        table[m2Hash] = uint32(s - 2)
+                        table[currHash] = uint32(s)
+                        if uint32(x>>16) != load32(src, candidate) {
+                                cv = load64(src, s+1)
+                                s++
+                                break
+                        }
+                }
+        }
+
+emitRemainder:
+        if nextEmit < len(src) {
+                // Bail if we exceed the maximum size.
+                if d+len(src)-nextEmit > dstLimit {
+                        return 0
+                }
+                d += emitLiteral(dst[d:], src[nextEmit:])
+        }
+        return d
+}
+
+// encodeBlockGo encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src)) &&
+//      minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
+func encodeBlockDictGo(dst, src []byte, dict *Dict) (d int) {
+        // Initialize the hash table.
+        const (
+                tableBits    = 14
+                maxTableSize = 1 << tableBits
+                maxAhead     = 8 // maximum bytes ahead without checking sLimit
+
+                debug = false
+        )
+        dict.initFast()
+
+        var table [maxTableSize]uint32
+
+        // sLimit is when to stop looking for offset/length copies. The inputMargin
+        // lets us use a fast path for emitLiteral in the main loop, while we are
+        // looking for copies.
+        sLimit := len(src) - inputMargin
+        if sLimit > MaxDictSrcOffset-maxAhead {
+                sLimit = MaxDictSrcOffset - maxAhead
+        }
+
+        // Bail if we can't compress to at least this.
+        dstLimit := len(src) - len(src)>>5 - 5
+
+        // nextEmit is where in src the next emitLiteral should start from.
+        nextEmit := 0
+
+        // The encoded form can start with a dict entry (copy or repeat).
+        s := 0
+
+        // Convert dict repeat to offset
+        repeat := len(dict.dict) - dict.repeat
+        cv := load64(src, 0)
+
+        // While in dict
+searchDict:
+        for {
+                // Next src position to check
+                nextS := s + (s-nextEmit)>>6 + 4
+                hash0 := hash6(cv, tableBits)
+                hash1 := hash6(cv>>8, tableBits)
+                if nextS > sLimit {
+                        if debug {
+                                fmt.Println("slimit reached", s, nextS)
+                        }
+                        break searchDict
+                }
+                candidateDict := int(dict.fastTable[hash0])
+                candidateDict2 := int(dict.fastTable[hash1])
+                candidate2 := int(table[hash1])
+                candidate := int(table[hash0])
+                table[hash0] = uint32(s)
+                table[hash1] = uint32(s + 1)
+                hash2 := hash6(cv>>16, tableBits)
+
+                // Check repeat at offset checkRep.
+                const checkRep = 1
+
+                if repeat > s {
+                        candidate := len(dict.dict) - repeat + s
+                        if repeat-s >= 4 && uint32(cv) == load32(dict.dict, candidate) {
+                                // Extend back
+                                base := s
+                                for i := candidate; base > nextEmit && i > 0 && dict.dict[i-1] == src[base-1]; {
+                                        i--
+                                        base--
+                                }
+                                d += emitLiteral(dst[d:], src[nextEmit:base])
+                                if debug && nextEmit != base {
+                                        fmt.Println("emitted ", base-nextEmit, "literals")
+                                }
+                                s += 4
+                                candidate += 4
+                                for candidate < len(dict.dict)-8 && s <= len(src)-8 {
+                                        if diff := load64(src, s) ^ load64(dict.dict, candidate); diff != 0 {
+                                                s += bits.TrailingZeros64(diff) >> 3
+                                                break
+                                        }
+                                        s += 8
+                                        candidate += 8
+                                }
+                                d += emitRepeat(dst[d:], repeat, s-base)
+                                if debug {
+                                        fmt.Println("emitted dict repeat length", s-base, "offset:", repeat, "s:", s)
+                                }
+                                nextEmit = s
+                                if s >= sLimit {
+                                        break searchDict
+                                }
+                                cv = load64(src, s)
+                                continue
+                        }
+                } else if uint32(cv>>(checkRep*8)) == load32(src, s-repeat+checkRep) {
+                        base := s + checkRep
+                        // Extend back
+                        for i := base - repeat; base > nextEmit && i > 0 && src[i-1] == src[base-1]; {
+                                i--
+                                base--
+                        }
+                        d += emitLiteral(dst[d:], src[nextEmit:base])
+                        if debug && nextEmit != base {
+                                fmt.Println("emitted ", base-nextEmit, "literals")
+                        }
+
+                        // Extend forward
+                        candidate := s - repeat + 4 + checkRep
+                        s += 4 + checkRep
+                        for s <= sLimit {
+                                if diff := load64(src, s) ^ load64(src, candidate); diff != 0 {
+                                        s += bits.TrailingZeros64(diff) >> 3
+                                        break
+                                }
+                                s += 8
+                                candidate += 8
+                        }
+                        if debug {
+                                // Validate match.
+                                if s <= candidate {
+                                        panic("s <= candidate")
+                                }
+                                a := src[base:s]
+                                b := src[base-repeat : base-repeat+(s-base)]
+                                if !bytes.Equal(a, b) {
+                                        panic("mismatch")
+                                }
+                        }
+
+                        if nextEmit > 0 {
+                                // same as `add := emitCopy(dst[d:], repeat, s-base)` but skips storing offset.
+                                d += emitRepeat(dst[d:], repeat, s-base)
+                        } else {
+                                // First match, cannot be repeat.
+                                d += emitCopy(dst[d:], repeat, s-base)
+                        }
+
+                        nextEmit = s
+                        if s >= sLimit {
+                                break searchDict
+                        }
+                        if debug {
+                                fmt.Println("emitted reg repeat", s-base, "s:", s)
+                        }
+                        cv = load64(src, s)
+                        continue searchDict
+                }
+                if s == 0 {
+                        cv = load64(src, nextS)
+                        s = nextS
+                        continue searchDict
+                }
+                // Start with table. These matches will always be closer.
+                if uint32(cv) == load32(src, candidate) {
+                        goto emitMatch
+                }
+                candidate = int(table[hash2])
+                if uint32(cv>>8) == load32(src, candidate2) {
+                        table[hash2] = uint32(s + 2)
+                        candidate = candidate2
+                        s++
+                        goto emitMatch
+                }
+
+                // Check dict. Dicts have longer offsets, so we want longer matches.
+                if cv == load64(dict.dict, candidateDict) {
+                        table[hash2] = uint32(s + 2)
+                        goto emitDict
+                }
+
+                candidateDict = int(dict.fastTable[hash2])
+                // Check if upper 7 bytes match
+                if candidateDict2 >= 1 {
+                        if cv^load64(dict.dict, candidateDict2-1) < (1 << 8) {
+                                table[hash2] = uint32(s + 2)
+                                candidateDict = candidateDict2
+                                s++
+                                goto emitDict
+                        }
+                }
+
+                table[hash2] = uint32(s + 2)
+                if uint32(cv>>16) == load32(src, candidate) {
+                        s += 2
+                        goto emitMatch
+                }
+                if candidateDict >= 2 {
+                        // Check if upper 6 bytes match
+                        if cv^load64(dict.dict, candidateDict-2) < (1 << 16) {
+                                s += 2
+                                goto emitDict
+                        }
+                }
+
+                cv = load64(src, nextS)
+                s = nextS
+                continue searchDict
+
+        emitDict:
+                {
+                        if debug {
+                                if load32(dict.dict, candidateDict) != load32(src, s) {
+                                        panic("dict emit mismatch")
+                                }
+                        }
+                        // Extend backwards.
+                        // The top bytes will be rechecked to get the full match.
+                        for candidateDict > 0 && s > nextEmit && dict.dict[candidateDict-1] == src[s-1] {
+                                candidateDict--
+                                s--
+                        }
+
+                        // Bail if we exceed the maximum size.
+                        if d+(s-nextEmit) > dstLimit {
+                                return 0
+                        }
+
+                        // A 4-byte match has been found. We'll later see if more than 4 bytes
+                        // match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
+                        // them as literal bytes.
+
+                        d += emitLiteral(dst[d:], src[nextEmit:s])
+                        if debug && nextEmit != s {
+                                fmt.Println("emitted ", s-nextEmit, "literals")
+                        }
+                        {
+                                // Invariant: we have a 4-byte match at s, and no need to emit any
+                                // literal bytes prior to s.
+                                base := s
+                                repeat = s + (len(dict.dict)) - candidateDict
+
+                                // Extend the 4-byte match as long as possible.
+                                s += 4
+                                candidateDict += 4
+                                for s <= len(src)-8 && len(dict.dict)-candidateDict >= 8 {
+                                        if diff := load64(src, s) ^ load64(dict.dict, candidateDict); diff != 0 {
+                                                s += bits.TrailingZeros64(diff) >> 3
+                                                break
+                                        }
+                                        s += 8
+                                        candidateDict += 8
+                                }
+
+                                // Matches longer than 64 are split.
+                                if s <= sLimit || s-base < 8 {
+                                        d += emitCopy(dst[d:], repeat, s-base)
+                                } else {
+                                        // Split to ensure we don't start a copy within next block
+                                        d += emitCopy(dst[d:], repeat, 4)
+                                        d += emitRepeat(dst[d:], repeat, s-base-4)
+                                }
+                                if false {
+                                        // Validate match.
+                                        if s <= candidate {
+                                                panic("s <= candidate")
+                                        }
+                                        a := src[base:s]
+                                        b := dict.dict[base-repeat : base-repeat+(s-base)]
+                                        if !bytes.Equal(a, b) {
+                                                panic("mismatch")
+                                        }
+                                }
+                                if debug {
+                                        fmt.Println("emitted dict copy, length", s-base, "offset:", repeat, "s:", s)
+                                }
+                                nextEmit = s
+                                if s >= sLimit {
+                                        break searchDict
+                                }
+
+                                if d > dstLimit {
+                                        // Do we have space for more, if not bail.
+                                        return 0
+                                }
+
+                                // Index and continue loop to try new candidate.
+                                x := load64(src, s-2)
+                                m2Hash := hash6(x, tableBits)
+                                currHash := hash6(x>>8, tableBits)
+                                table[m2Hash] = uint32(s - 2)
+                                table[currHash] = uint32(s - 1)
+                                cv = load64(src, s)
+                        }
+                        continue
+                }
+        emitMatch:
+
+                // Extend backwards.
+                // The top bytes will be rechecked to get the full match.
+                for candidate > 0 && s > nextEmit && src[candidate-1] == src[s-1] {
+                        candidate--
+                        s--
+                }
+
+                // Bail if we exceed the maximum size.
+                if d+(s-nextEmit) > dstLimit {
+                        return 0
+                }
+
+                // A 4-byte match has been found. We'll later see if more than 4 bytes
+                // match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
+                // them as literal bytes.
+
+                d += emitLiteral(dst[d:], src[nextEmit:s])
+                if debug && nextEmit != s {
+                        fmt.Println("emitted ", s-nextEmit, "literals")
+                }
+                // Call emitCopy, and then see if another emitCopy could be our next
+                // move. Repeat until we find no match for the input immediately after
+                // what was consumed by the last emitCopy call.
+                //
+                // If we exit this loop normally then we need to call emitLiteral next,
+                // though we don't yet know how big the literal will be. We handle that
+                // by proceeding to the next iteration of the main loop. We also can
+                // exit this loop via goto if we get close to exhausting the input.
+                for {
+                        // Invariant: we have a 4-byte match at s, and no need to emit any
+                        // literal bytes prior to s.
+                        base := s
+                        repeat = base - candidate
+
+                        // Extend the 4-byte match as long as possible.
+                        s += 4
+                        candidate += 4
+                        for s <= len(src)-8 {
+                                if diff := load64(src, s) ^ load64(src, candidate); diff != 0 {
+                                        s += bits.TrailingZeros64(diff) >> 3
+                                        break
+                                }
+                                s += 8
+                                candidate += 8
+                        }
+
+                        d += emitCopy(dst[d:], repeat, s-base)
+                        if debug {
+                                // Validate match.
+                                if s <= candidate {
+                                        panic("s <= candidate")
+                                }
+                                a := src[base:s]
+                                b := src[base-repeat : base-repeat+(s-base)]
+                                if !bytes.Equal(a, b) {
+                                        panic("mismatch")
+                                }
+                        }
+                        if debug {
+                                fmt.Println("emitted src copy, length", s-base, "offset:", repeat, "s:", s)
+                        }
+                        nextEmit = s
+                        if s >= sLimit {
+                                break searchDict
+                        }
+
+                        if d > dstLimit {
+                                // Do we have space for more, if not bail.
+                                return 0
+                        }
+                        // Check for an immediate match, otherwise start search at s+1
+                        x := load64(src, s-2)
+                        m2Hash := hash6(x, tableBits)
+                        currHash := hash6(x>>16, tableBits)
+                        candidate = int(table[currHash])
+                        table[m2Hash] = uint32(s - 2)
+                        table[currHash] = uint32(s)
+                        if debug && s == candidate {
+                                panic("s == candidate")
+                        }
+                        if uint32(x>>16) != load32(src, candidate) {
+                                cv = load64(src, s+1)
+                                s++
+                                break
+                        }
+                }
+        }
+
+        // Search without dict:
+        if repeat > s {
+                repeat = 0
+        }
+
+        // No more dict
+        sLimit = len(src) - inputMargin
+        if s >= sLimit {
+                goto emitRemainder
+        }
+        if debug {
+                fmt.Println("non-dict matching at", s, "repeat:", repeat)
+        }
+        cv = load64(src, s)
+        if debug {
+                fmt.Println("now", s, "->", sLimit, "out:", d, "left:", len(src)-s, "nextemit:", nextEmit, "dstLimit:", dstLimit, "s:", s)
+        }
+        for {
+                candidate := 0
+                for {
+                        // Next src position to check
+                        nextS := s + (s-nextEmit)>>6 + 4
+                        if nextS > sLimit {
+                                goto emitRemainder
+                        }
+                        hash0 := hash6(cv, tableBits)
+                        hash1 := hash6(cv>>8, tableBits)
+                        candidate = int(table[hash0])
+                        candidate2 := int(table[hash1])
+                        table[hash0] = uint32(s)
+                        table[hash1] = uint32(s + 1)
+                        hash2 := hash6(cv>>16, tableBits)
+
+                        // Check repeat at offset checkRep.
+                        const checkRep = 1
+                        if repeat > 0 && uint32(cv>>(checkRep*8)) == load32(src, s-repeat+checkRep) {
+                                base := s + checkRep
+                                // Extend back
+                                for i := base - repeat; base > nextEmit && i > 0 && src[i-1] == src[base-1]; {
+                                        i--
+                                        base--
+                                }
+                                d += emitLiteral(dst[d:], src[nextEmit:base])
+                                if debug && nextEmit != base {
+                                        fmt.Println("emitted ", base-nextEmit, "literals")
+                                }
+                                // Extend forward
+                                candidate := s - repeat + 4 + checkRep
+                                s += 4 + checkRep
+                                for s <= sLimit {
+                                        if diff := load64(src, s) ^ load64(src, candidate); diff != 0 {
+                                                s += bits.TrailingZeros64(diff) >> 3
+                                                break
+                                        }
+                                        s += 8
+                                        candidate += 8
+                                }
+                                if debug {
+                                        // Validate match.
+                                        if s <= candidate {
+                                                panic("s <= candidate")
+                                        }
+                                        a := src[base:s]
+                                        b := src[base-repeat : base-repeat+(s-base)]
+                                        if !bytes.Equal(a, b) {
+                                                panic("mismatch")
+                                        }
+                                }
+                                if nextEmit > 0 {
+                                        // same as `add := emitCopy(dst[d:], repeat, s-base)` but skips storing offset.
+                                        d += emitRepeat(dst[d:], repeat, s-base)
+                                } else {
+                                        // First match, cannot be repeat.
+                                        d += emitCopy(dst[d:], repeat, s-base)
+                                }
+                                if debug {
+                                        fmt.Println("emitted src repeat length", s-base, "offset:", repeat, "s:", s)
+                                }
+                                nextEmit = s
+                                if s >= sLimit {
+                                        goto emitRemainder
+                                }
+
+                                cv = load64(src, s)
+                                continue
+                        }
+
+                        if uint32(cv) == load32(src, candidate) {
+                                break
+                        }
+                        candidate = int(table[hash2])
+                        if uint32(cv>>8) == load32(src, candidate2) {
+                                table[hash2] = uint32(s + 2)
+                                candidate = candidate2
+                                s++
+                                break
+                        }
+                        table[hash2] = uint32(s + 2)
+                        if uint32(cv>>16) == load32(src, candidate) {
+                                s += 2
+                                break
+                        }
+
+                        cv = load64(src, nextS)
+                        s = nextS
+                }
+
+                // Extend backwards.
+                // The top bytes will be rechecked to get the full match.
+                for candidate > 0 && s > nextEmit && src[candidate-1] == src[s-1] {
+                        candidate--
+                        s--
+                }
+
+                // Bail if we exceed the maximum size.
+                if d+(s-nextEmit) > dstLimit {
+                        return 0
+                }
+
+                // A 4-byte match has been found. We'll later see if more than 4 bytes
+                // match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
+                // them as literal bytes.
+
+                d += emitLiteral(dst[d:], src[nextEmit:s])
+                if debug && nextEmit != s {
+                        fmt.Println("emitted ", s-nextEmit, "literals")
+                }
+                // Call emitCopy, and then see if another emitCopy could be our next
+                // move. Repeat until we find no match for the input immediately after
+                // what was consumed by the last emitCopy call.
+                //
+                // If we exit this loop normally then we need to call emitLiteral next,
+                // though we don't yet know how big the literal will be. We handle that
+                // by proceeding to the next iteration of the main loop. We also can
+                // exit this loop via goto if we get close to exhausting the input.
+                for {
+                        // Invariant: we have a 4-byte match at s, and no need to emit any
+                        // literal bytes prior to s.
+                        base := s
+                        repeat = base - candidate
+
+                        // Extend the 4-byte match as long as possible.
+                        s += 4
+                        candidate += 4
+                        for s <= len(src)-8 {
+                                if diff := load64(src, s) ^ load64(src, candidate); diff != 0 {
+                                        s += bits.TrailingZeros64(diff) >> 3
+                                        break
+                                }
+                                s += 8
+                                candidate += 8
+                        }
+
+                        d += emitCopy(dst[d:], repeat, s-base)
+                        if debug {
+                                // Validate match.
+                                if s <= candidate {
+                                        panic("s <= candidate")
+                                }
+                                a := src[base:s]
+                                b := src[base-repeat : base-repeat+(s-base)]
+                                if !bytes.Equal(a, b) {
+                                        panic("mismatch")
+                                }
+                        }
+                        if debug {
+                                fmt.Println("emitted src copy, length", s-base, "offset:", repeat, "s:", s)
+                        }
+                        nextEmit = s
+                        if s >= sLimit {
+                                goto emitRemainder
+                        }
+
+                        if d > dstLimit {
+                                // Do we have space for more, if not bail.
+                                return 0
+                        }
+                        // Check for an immediate match, otherwise start search at s+1
+                        x := load64(src, s-2)
+                        m2Hash := hash6(x, tableBits)
+                        currHash := hash6(x>>16, tableBits)
+                        candidate = int(table[currHash])
+                        table[m2Hash] = uint32(s - 2)
+                        table[currHash] = uint32(s)
+                        if debug && s == candidate {
+                                panic("s == candidate")
+                        }
+                        if uint32(x>>16) != load32(src, candidate) {
+                                cv = load64(src, s+1)
+                                s++
+                                break
+                        }
+                }
+        }
+
+emitRemainder:
+        if nextEmit < len(src) {
+                // Bail if we exceed the maximum size.
+                if d+len(src)-nextEmit > dstLimit {
+                        return 0
+                }
+                d += emitLiteral(dst[d:], src[nextEmit:])
+                if debug && nextEmit != s {
+                        fmt.Println("emitted ", len(src)-nextEmit, "literals")
+                }
+        }
+        return d
+}
diff --git a/vendor/github.com/klauspost/compress/s2/encode_amd64.go b/vendor/github.com/klauspost/compress/s2/encode_amd64.go
new file mode 100644
index 0000000..ebc332a
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/encode_amd64.go
@@ -0,0 +1,148 @@
+//go:build !appengine && !noasm && gc
+// +build !appengine,!noasm,gc
+
+package s2
+
+const hasAmd64Asm = true
+
+// encodeBlock encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src)) &&
+//      minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
+func encodeBlock(dst, src []byte) (d int) {
+        const (
+                // Use 12 bit table when less than...
+                limit12B = 16 << 10
+                // Use 10 bit table when less than...
+                limit10B = 4 << 10
+                // Use 8 bit table when less than...
+                limit8B = 512
+        )
+
+        if len(src) >= 4<<20 {
+                return encodeBlockAsm(dst, src)
+        }
+        if len(src) >= limit12B {
+                return encodeBlockAsm4MB(dst, src)
+        }
+        if len(src) >= limit10B {
+                return encodeBlockAsm12B(dst, src)
+        }
+        if len(src) >= limit8B {
+                return encodeBlockAsm10B(dst, src)
+        }
+        if len(src) < minNonLiteralBlockSize {
+                return 0
+        }
+        return encodeBlockAsm8B(dst, src)
+}
+
+// encodeBlockBetter encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src)) &&
+//      minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
+func encodeBlockBetter(dst, src []byte) (d int) {
+        const (
+                // Use 12 bit table when less than...
+                limit12B = 16 << 10
+                // Use 10 bit table when less than...
+                limit10B = 4 << 10
+                // Use 8 bit table when less than...
+                limit8B = 512
+        )
+
+        if len(src) > 4<<20 {
+                return encodeBetterBlockAsm(dst, src)
+        }
+        if len(src) >= limit12B {
+                return encodeBetterBlockAsm4MB(dst, src)
+        }
+        if len(src) >= limit10B {
+                return encodeBetterBlockAsm12B(dst, src)
+        }
+        if len(src) >= limit8B {
+                return encodeBetterBlockAsm10B(dst, src)
+        }
+        if len(src) < minNonLiteralBlockSize {
+                return 0
+        }
+        return encodeBetterBlockAsm8B(dst, src)
+}
+
+// encodeBlockSnappy encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src)) &&
+//      minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
+func encodeBlockSnappy(dst, src []byte) (d int) {
+        const (
+                // Use 12 bit table when less than...
+                limit12B = 16 << 10
+                // Use 10 bit table when less than...
+                limit10B = 4 << 10
+                // Use 8 bit table when less than...
+                limit8B = 512
+        )
+        if len(src) >= 64<<10 {
+                return encodeSnappyBlockAsm(dst, src)
+        }
+        if len(src) >= limit12B {
+                return encodeSnappyBlockAsm64K(dst, src)
+        }
+        if len(src) >= limit10B {
+                return encodeSnappyBlockAsm12B(dst, src)
+        }
+        if len(src) >= limit8B {
+                return encodeSnappyBlockAsm10B(dst, src)
+        }
+        if len(src) < minNonLiteralBlockSize {
+                return 0
+        }
+        return encodeSnappyBlockAsm8B(dst, src)
+}
+
+// encodeBlockSnappy encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src)) &&
+//      minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
+func encodeBlockBetterSnappy(dst, src []byte) (d int) {
+        const (
+                // Use 12 bit table when less than...
+                limit12B = 16 << 10
+                // Use 10 bit table when less than...
+                limit10B = 4 << 10
+                // Use 8 bit table when less than...
+                limit8B = 512
+        )
+        if len(src) >= 64<<10 {
+                return encodeSnappyBetterBlockAsm(dst, src)
+        }
+        if len(src) >= limit12B {
+                return encodeSnappyBetterBlockAsm64K(dst, src)
+        }
+        if len(src) >= limit10B {
+                return encodeSnappyBetterBlockAsm12B(dst, src)
+        }
+        if len(src) >= limit8B {
+                return encodeSnappyBetterBlockAsm10B(dst, src)
+        }
+        if len(src) < minNonLiteralBlockSize {
+                return 0
+        }
+        return encodeSnappyBetterBlockAsm8B(dst, src)
+}
diff --git a/vendor/github.com/klauspost/compress/s2/encode_best.go b/vendor/github.com/klauspost/compress/s2/encode_best.go
new file mode 100644
index 0000000..47bac74
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/encode_best.go
@@ -0,0 +1,796 @@
+// Copyright 2016 The Snappy-Go Authors. All rights reserved.
+// Copyright (c) 2019 Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s2
+
+import (
+        "fmt"
+        "math"
+        "math/bits"
+)
+
+// encodeBlockBest encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src)) &&
+//      minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
+func encodeBlockBest(dst, src []byte, dict *Dict) (d int) {
+        // Initialize the hash tables.
+        const (
+                // Long hash matches.
+                lTableBits    = 19
+                maxLTableSize = 1 << lTableBits
+
+                // Short hash matches.
+                sTableBits    = 16
+                maxSTableSize = 1 << sTableBits
+
+                inputMargin = 8 + 2
+
+                debug = false
+        )
+
+        // sLimit is when to stop looking for offset/length copies. The inputMargin
+        // lets us use a fast path for emitLiteral in the main loop, while we are
+        // looking for copies.
+        sLimit := len(src) - inputMargin
+        if len(src) < minNonLiteralBlockSize {
+                return 0
+        }
+        sLimitDict := len(src) - inputMargin
+        if sLimitDict > MaxDictSrcOffset-inputMargin {
+                sLimitDict = MaxDictSrcOffset - inputMargin
+        }
+
+        var lTable [maxLTableSize]uint64
+        var sTable [maxSTableSize]uint64
+
+        // Bail if we can't compress to at least this.
+        dstLimit := len(src) - 5
+
+        // nextEmit is where in src the next emitLiteral should start from.
+        nextEmit := 0
+
+        // The encoded form must start with a literal, as there are no previous
+        // bytes to copy, so we start looking for hash matches at s == 1.
+        s := 1
+        repeat := 1
+        if dict != nil {
+                dict.initBest()
+                s = 0
+                repeat = len(dict.dict) - dict.repeat
+        }
+        cv := load64(src, s)
+
+        // We search for a repeat at -1, but don't output repeats when nextEmit == 0
+        const lowbitMask = 0xffffffff
+        getCur := func(x uint64) int {
+                return int(x & lowbitMask)
+        }
+        getPrev := func(x uint64) int {
+                return int(x >> 32)
+        }
+        const maxSkip = 64
+
+        for {
+                type match struct {
+                        offset    int
+                        s         int
+                        length    int
+                        score     int
+                        rep, dict bool
+                }
+                var best match
+                for {
+                        // Next src position to check
+                        nextS := (s-nextEmit)>>8 + 1
+                        if nextS > maxSkip {
+                                nextS = s + maxSkip
+                        } else {
+                                nextS += s
+                        }
+                        if nextS > sLimit {
+                                goto emitRemainder
+                        }
+                        if dict != nil && s >= MaxDictSrcOffset {
+                                dict = nil
+                                if repeat > s {
+                                        repeat = math.MinInt32
+                                }
+                        }
+                        hashL := hash8(cv, lTableBits)
+                        hashS := hash4(cv, sTableBits)
+                        candidateL := lTable[hashL]
+                        candidateS := sTable[hashS]
+
+                        score := func(m match) int {
+                                // Matches that are longer forward are penalized since we must emit it as a literal.
+                                score := m.length - m.s
+                                if nextEmit == m.s {
+                                        // If we do not have to emit literals, we save 1 byte
+                                        score++
+                                }
+                                offset := m.s - m.offset
+                                if m.rep {
+                                        return score - emitRepeatSize(offset, m.length)
+                                }
+                                return score - emitCopySize(offset, m.length)
+                        }
+
+                        matchAt := func(offset, s int, first uint32, rep bool) match {
+                                if best.length != 0 && best.s-best.offset == s-offset {
+                                        // Don't retest if we have the same offset.
+                                        return match{offset: offset, s: s}
+                                }
+                                if load32(src, offset) != first {
+                                        return match{offset: offset, s: s}
+                                }
+                                m := match{offset: offset, s: s, length: 4 + offset, rep: rep}
+                                s += 4
+                                for s < len(src) {
+                                        if len(src)-s < 8 {
+                                                if src[s] == src[m.length] {
+                                                        m.length++
+                                                        s++
+                                                        continue
+                                                }
+                                                break
+                                        }
+                                        if diff := load64(src, s) ^ load64(src, m.length); diff != 0 {
+                                                m.length += bits.TrailingZeros64(diff) >> 3
+                                                break
+                                        }
+                                        s += 8
+                                        m.length += 8
+                                }
+                                m.length -= offset
+                                m.score = score(m)
+                                if m.score <= -m.s {
+                                        // Eliminate if no savings, we might find a better one.
+                                        m.length = 0
+                                }
+                                return m
+                        }
+                        matchDict := func(candidate, s int, first uint32, rep bool) match {
+                                if s >= MaxDictSrcOffset {
+                                        return match{offset: candidate, s: s}
+                                }
+                                // Calculate offset as if in continuous array with s
+                                offset := -len(dict.dict) + candidate
+                                if best.length != 0 && best.s-best.offset == s-offset && !rep {
+                                        // Don't retest if we have the same offset.
+                                        return match{offset: offset, s: s}
+                                }
+
+                                if load32(dict.dict, candidate) != first {
+                                        return match{offset: offset, s: s}
+                                }
+                                m := match{offset: offset, s: s, length: 4 + candidate, rep: rep, dict: true}
+                                s += 4
+                                if !rep {
+                                        for s < sLimitDict && m.length < len(dict.dict) {
+                                                if len(src)-s < 8 || len(dict.dict)-m.length < 8 {
+                                                        if src[s] == dict.dict[m.length] {
+                                                                m.length++
+                                                                s++
+                                                                continue
+                                                        }
+                                                        break
+                                                }
+                                                if diff := load64(src, s) ^ load64(dict.dict, m.length); diff != 0 {
+                                                        m.length += bits.TrailingZeros64(diff) >> 3
+                                                        break
+                                                }
+                                                s += 8
+                                                m.length += 8
+                                        }
+                                } else {
+                                        for s < len(src) && m.length < len(dict.dict) {
+                                                if len(src)-s < 8 || len(dict.dict)-m.length < 8 {
+                                                        if src[s] == dict.dict[m.length] {
+                                                                m.length++
+                                                                s++
+                                                                continue
+                                                        }
+                                                        break
+                                                }
+                                                if diff := load64(src, s) ^ load64(dict.dict, m.length); diff != 0 {
+                                                        m.length += bits.TrailingZeros64(diff) >> 3
+                                                        break
+                                                }
+                                                s += 8
+                                                m.length += 8
+                                        }
+                                }
+                                m.length -= candidate
+                                m.score = score(m)
+                                if m.score <= -m.s {
+                                        // Eliminate if no savings, we might find a better one.
+                                        m.length = 0
+                                }
+                                return m
+                        }
+
+                        bestOf := func(a, b match) match {
+                                if b.length == 0 {
+                                        return a
+                                }
+                                if a.length == 0 {
+                                        return b
+                                }
+                                as := a.score + b.s
+                                bs := b.score + a.s
+                                if as >= bs {
+                                        return a
+                                }
+                                return b
+                        }
+
+                        if s > 0 {
+                                best = bestOf(matchAt(getCur(candidateL), s, uint32(cv), false), matchAt(getPrev(candidateL), s, uint32(cv), false))
+                                best = bestOf(best, matchAt(getCur(candidateS), s, uint32(cv), false))
+                                best = bestOf(best, matchAt(getPrev(candidateS), s, uint32(cv), false))
+                        }
+                        if dict != nil {
+                                candidateL := dict.bestTableLong[hashL]
+                                candidateS := dict.bestTableShort[hashS]
+                                best = bestOf(best, matchDict(int(candidateL&0xffff), s, uint32(cv), false))
+                                best = bestOf(best, matchDict(int(candidateL>>16), s, uint32(cv), false))
+                                best = bestOf(best, matchDict(int(candidateS&0xffff), s, uint32(cv), false))
+                                best = bestOf(best, matchDict(int(candidateS>>16), s, uint32(cv), false))
+                        }
+                        {
+                                if (dict == nil || repeat <= s) && repeat > 0 {
+                                        best = bestOf(best, matchAt(s-repeat+1, s+1, uint32(cv>>8), true))
+                                } else if s-repeat < -4 && dict != nil {
+                                        candidate := len(dict.dict) - (repeat - s)
+                                        best = bestOf(best, matchDict(candidate, s, uint32(cv), true))
+                                        candidate++
+                                        best = bestOf(best, matchDict(candidate, s+1, uint32(cv>>8), true))
+                                }
+
+                                if best.length > 0 {
+                                        hashS := hash4(cv>>8, sTableBits)
+                                        // s+1
+                                        nextShort := sTable[hashS]
+                                        s := s + 1
+                                        cv := load64(src, s)
+                                        hashL := hash8(cv, lTableBits)
+                                        nextLong := lTable[hashL]
+                                        best = bestOf(best, matchAt(getCur(nextShort), s, uint32(cv), false))
+                                        best = bestOf(best, matchAt(getPrev(nextShort), s, uint32(cv), false))
+                                        best = bestOf(best, matchAt(getCur(nextLong), s, uint32(cv), false))
+                                        best = bestOf(best, matchAt(getPrev(nextLong), s, uint32(cv), false))
+
+                                        // Dict at + 1
+                                        if dict != nil {
+                                                candidateL := dict.bestTableLong[hashL]
+                                                candidateS := dict.bestTableShort[hashS]
+
+                                                best = bestOf(best, matchDict(int(candidateL&0xffff), s, uint32(cv), false))
+                                                best = bestOf(best, matchDict(int(candidateS&0xffff), s, uint32(cv), false))
+                                        }
+
+                                        // s+2
+                                        if true {
+                                                hashS := hash4(cv>>8, sTableBits)
+
+                                                nextShort = sTable[hashS]
+                                                s++
+                                                cv = load64(src, s)
+                                                hashL := hash8(cv, lTableBits)
+                                                nextLong = lTable[hashL]
+
+                                                if (dict == nil || repeat <= s) && repeat > 0 {
+                                                        // Repeat at + 2
+                                                        best = bestOf(best, matchAt(s-repeat, s, uint32(cv), true))
+                                                } else if repeat-s > 4 && dict != nil {
+                                                        candidate := len(dict.dict) - (repeat - s)
+                                                        best = bestOf(best, matchDict(candidate, s, uint32(cv), true))
+                                                }
+                                                best = bestOf(best, matchAt(getCur(nextShort), s, uint32(cv), false))
+                                                best = bestOf(best, matchAt(getPrev(nextShort), s, uint32(cv), false))
+                                                best = bestOf(best, matchAt(getCur(nextLong), s, uint32(cv), false))
+                                                best = bestOf(best, matchAt(getPrev(nextLong), s, uint32(cv), false))
+
+                                                // Dict at +2
+                                                // Very small gain
+                                                if dict != nil {
+                                                        candidateL := dict.bestTableLong[hashL]
+                                                        candidateS := dict.bestTableShort[hashS]
+
+                                                        best = bestOf(best, matchDict(int(candidateL&0xffff), s, uint32(cv), false))
+                                                        best = bestOf(best, matchDict(int(candidateS&0xffff), s, uint32(cv), false))
+                                                }
+                                        }
+                                        // Search for a match at best match end, see if that is better.
+                                        // Allow some bytes at the beginning to mismatch.
+                                        // Sweet spot is around 1-2 bytes, but depends on input.
+                                        // The skipped bytes are tested in Extend backwards,
+                                        // and still picked up as part of the match if they do.
+                                        const skipBeginning = 2
+                                        const skipEnd = 1
+                                        if sAt := best.s + best.length - skipEnd; sAt < sLimit {
+
+                                                sBack := best.s + skipBeginning - skipEnd
+                                                backL := best.length - skipBeginning
+                                                // Load initial values
+                                                cv = load64(src, sBack)
+
+                                                // Grab candidates...
+                                                next := lTable[hash8(load64(src, sAt), lTableBits)]
+
+                                                if checkAt := getCur(next) - backL; checkAt > 0 {
+                                                        best = bestOf(best, matchAt(checkAt, sBack, uint32(cv), false))
+                                                }
+                                                if checkAt := getPrev(next) - backL; checkAt > 0 {
+                                                        best = bestOf(best, matchAt(checkAt, sBack, uint32(cv), false))
+                                                }
+                                                // Disabled: Extremely small gain
+                                                if false {
+                                                        next = sTable[hash4(load64(src, sAt), sTableBits)]
+                                                        if checkAt := getCur(next) - backL; checkAt > 0 {
+                                                                best = bestOf(best, matchAt(checkAt, sBack, uint32(cv), false))
+                                                        }
+                                                        if checkAt := getPrev(next) - backL; checkAt > 0 {
+                                                                best = bestOf(best, matchAt(checkAt, sBack, uint32(cv), false))
+                                                        }
+                                                }
+                                        }
+                                }
+                        }
+
+                        // Update table
+                        lTable[hashL] = uint64(s) | candidateL<<32
+                        sTable[hashS] = uint64(s) | candidateS<<32
+
+                        if best.length > 0 {
+                                break
+                        }
+
+                        cv = load64(src, nextS)
+                        s = nextS
+                }
+
+                // Extend backwards, not needed for repeats...
+                s = best.s
+                if !best.rep && !best.dict {
+                        for best.offset > 0 && s > nextEmit && src[best.offset-1] == src[s-1] {
+                                best.offset--
+                                best.length++
+                                s--
+                        }
+                }
+                if false && best.offset >= s {
+                        panic(fmt.Errorf("t %d >= s %d", best.offset, s))
+                }
+                // Bail if we exceed the maximum size.
+                if d+(s-nextEmit) > dstLimit {
+                        return 0
+                }
+
+                base := s
+                offset := s - best.offset
+                s += best.length
+
+                if offset > 65535 && s-base <= 5 && !best.rep {
+                        // Bail if the match is equal or worse to the encoding.
+                        s = best.s + 1
+                        if s >= sLimit {
+                                goto emitRemainder
+                        }
+                        cv = load64(src, s)
+                        continue
+                }
+                if debug && nextEmit != base {
+                        fmt.Println("EMIT", base-nextEmit, "literals. base-after:", base)
+                }
+                d += emitLiteral(dst[d:], src[nextEmit:base])
+                if best.rep {
+                        if nextEmit > 0 || best.dict {
+                                if debug {
+                                        fmt.Println("REPEAT, length", best.length, "offset:", offset, "s-after:", s, "dict:", best.dict, "best:", best)
+                                }
+                                // same as `add := emitCopy(dst[d:], repeat, s-base)` but skips storing offset.
+                                d += emitRepeat(dst[d:], offset, best.length)
+                        } else {
+                                // First match without dict cannot be a repeat.
+                                if debug {
+                                        fmt.Println("COPY, length", best.length, "offset:", offset, "s-after:", s, "dict:", best.dict, "best:", best)
+                                }
+                                d += emitCopy(dst[d:], offset, best.length)
+                        }
+                } else {
+                        if debug {
+                                fmt.Println("COPY, length", best.length, "offset:", offset, "s-after:", s, "dict:", best.dict, "best:", best)
+                        }
+                        d += emitCopy(dst[d:], offset, best.length)
+                }
+                repeat = offset
+
+                nextEmit = s
+                if s >= sLimit {
+                        goto emitRemainder
+                }
+
+                if d > dstLimit {
+                        // Do we have space for more, if not bail.
+                        return 0
+                }
+                // Fill tables...
+                for i := best.s + 1; i < s; i++ {
+                        cv0 := load64(src, i)
+                        long0 := hash8(cv0, lTableBits)
+                        short0 := hash4(cv0, sTableBits)
+                        lTable[long0] = uint64(i) | lTable[long0]<<32
+                        sTable[short0] = uint64(i) | sTable[short0]<<32
+                }
+                cv = load64(src, s)
+        }
+
+emitRemainder:
+        if nextEmit < len(src) {
+                // Bail if we exceed the maximum size.
+                if d+len(src)-nextEmit > dstLimit {
+                        return 0
+                }
+                if debug && nextEmit != s {
+                        fmt.Println("emitted ", len(src)-nextEmit, "literals")
+                }
+                d += emitLiteral(dst[d:], src[nextEmit:])
+        }
+        return d
+}
+
+// encodeBlockBestSnappy encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src)) &&
+//      minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
+func encodeBlockBestSnappy(dst, src []byte) (d int) {
+        // Initialize the hash tables.
+        const (
+                // Long hash matches.
+                lTableBits    = 19
+                maxLTableSize = 1 << lTableBits
+
+                // Short hash matches.
+                sTableBits    = 16
+                maxSTableSize = 1 << sTableBits
+
+                inputMargin = 8 + 2
+        )
+
+        // sLimit is when to stop looking for offset/length copies. The inputMargin
+        // lets us use a fast path for emitLiteral in the main loop, while we are
+        // looking for copies.
+        sLimit := len(src) - inputMargin
+        if len(src) < minNonLiteralBlockSize {
+                return 0
+        }
+
+        var lTable [maxLTableSize]uint64
+        var sTable [maxSTableSize]uint64
+
+        // Bail if we can't compress to at least this.
+        dstLimit := len(src) - 5
+
+        // nextEmit is where in src the next emitLiteral should start from.
+        nextEmit := 0
+
+        // The encoded form must start with a literal, as there are no previous
+        // bytes to copy, so we start looking for hash matches at s == 1.
+        s := 1
+        cv := load64(src, s)
+
+        // We search for a repeat at -1, but don't output repeats when nextEmit == 0
+        repeat := 1
+        const lowbitMask = 0xffffffff
+        getCur := func(x uint64) int {
+                return int(x & lowbitMask)
+        }
+        getPrev := func(x uint64) int {
+                return int(x >> 32)
+        }
+        const maxSkip = 64
+
+        for {
+                type match struct {
+                        offset int
+                        s      int
+                        length int
+                        score  int
+                }
+                var best match
+                for {
+                        // Next src position to check
+                        nextS := (s-nextEmit)>>8 + 1
+                        if nextS > maxSkip {
+                                nextS = s + maxSkip
+                        } else {
+                                nextS += s
+                        }
+                        if nextS > sLimit {
+                                goto emitRemainder
+                        }
+                        hashL := hash8(cv, lTableBits)
+                        hashS := hash4(cv, sTableBits)
+                        candidateL := lTable[hashL]
+                        candidateS := sTable[hashS]
+
+                        score := func(m match) int {
+                                // Matches that are longer forward are penalized since we must emit it as a literal.
+                                score := m.length - m.s
+                                if nextEmit == m.s {
+                                        // If we do not have to emit literals, we save 1 byte
+                                        score++
+                                }
+                                offset := m.s - m.offset
+
+                                return score - emitCopyNoRepeatSize(offset, m.length)
+                        }
+
+                        matchAt := func(offset, s int, first uint32) match {
+                                if best.length != 0 && best.s-best.offset == s-offset {
+                                        // Don't retest if we have the same offset.
+                                        return match{offset: offset, s: s}
+                                }
+                                if load32(src, offset) != first {
+                                        return match{offset: offset, s: s}
+                                }
+                                m := match{offset: offset, s: s, length: 4 + offset}
+                                s += 4
+                                for s <= sLimit {
+                                        if diff := load64(src, s) ^ load64(src, m.length); diff != 0 {
+                                                m.length += bits.TrailingZeros64(diff) >> 3
+                                                break
+                                        }
+                                        s += 8
+                                        m.length += 8
+                                }
+                                m.length -= offset
+                                m.score = score(m)
+                                if m.score <= -m.s {
+                                        // Eliminate if no savings, we might find a better one.
+                                        m.length = 0
+                                }
+                                return m
+                        }
+
+                        bestOf := func(a, b match) match {
+                                if b.length == 0 {
+                                        return a
+                                }
+                                if a.length == 0 {
+                                        return b
+                                }
+                                as := a.score + b.s
+                                bs := b.score + a.s
+                                if as >= bs {
+                                        return a
+                                }
+                                return b
+                        }
+
+                        best = bestOf(matchAt(getCur(candidateL), s, uint32(cv)), matchAt(getPrev(candidateL), s, uint32(cv)))
+                        best = bestOf(best, matchAt(getCur(candidateS), s, uint32(cv)))
+                        best = bestOf(best, matchAt(getPrev(candidateS), s, uint32(cv)))
+
+                        {
+                                best = bestOf(best, matchAt(s-repeat+1, s+1, uint32(cv>>8)))
+                                if best.length > 0 {
+                                        // s+1
+                                        nextShort := sTable[hash4(cv>>8, sTableBits)]
+                                        s := s + 1
+                                        cv := load64(src, s)
+                                        nextLong := lTable[hash8(cv, lTableBits)]
+                                        best = bestOf(best, matchAt(getCur(nextShort), s, uint32(cv)))
+                                        best = bestOf(best, matchAt(getPrev(nextShort), s, uint32(cv)))
+                                        best = bestOf(best, matchAt(getCur(nextLong), s, uint32(cv)))
+                                        best = bestOf(best, matchAt(getPrev(nextLong), s, uint32(cv)))
+                                        // Repeat at + 2
+                                        best = bestOf(best, matchAt(s-repeat+1, s+1, uint32(cv>>8)))
+
+                                        // s+2
+                                        if true {
+                                                nextShort = sTable[hash4(cv>>8, sTableBits)]
+                                                s++
+                                                cv = load64(src, s)
+                                                nextLong = lTable[hash8(cv, lTableBits)]
+                                                best = bestOf(best, matchAt(getCur(nextShort), s, uint32(cv)))
+                                                best = bestOf(best, matchAt(getPrev(nextShort), s, uint32(cv)))
+                                                best = bestOf(best, matchAt(getCur(nextLong), s, uint32(cv)))
+                                                best = bestOf(best, matchAt(getPrev(nextLong), s, uint32(cv)))
+                                        }
+                                        // Search for a match at best match end, see if that is better.
+                                        if sAt := best.s + best.length; sAt < sLimit {
+                                                sBack := best.s
+                                                backL := best.length
+                                                // Load initial values
+                                                cv = load64(src, sBack)
+                                                // Search for mismatch
+                                                next := lTable[hash8(load64(src, sAt), lTableBits)]
+                                                //next := sTable[hash4(load64(src, sAt), sTableBits)]
+
+                                                if checkAt := getCur(next) - backL; checkAt > 0 {
+                                                        best = bestOf(best, matchAt(checkAt, sBack, uint32(cv)))
+                                                }
+                                                if checkAt := getPrev(next) - backL; checkAt > 0 {
+                                                        best = bestOf(best, matchAt(checkAt, sBack, uint32(cv)))
+                                                }
+                                        }
+                                }
+                        }
+
+                        // Update table
+                        lTable[hashL] = uint64(s) | candidateL<<32
+                        sTable[hashS] = uint64(s) | candidateS<<32
+
+                        if best.length > 0 {
+                                break
+                        }
+
+                        cv = load64(src, nextS)
+                        s = nextS
+                }
+
+                // Extend backwards, not needed for repeats...
+                s = best.s
+                if true {
+                        for best.offset > 0 && s > nextEmit && src[best.offset-1] == src[s-1] {
+                                best.offset--
+                                best.length++
+                                s--
+                        }
+                }
+                if false && best.offset >= s {
+                        panic(fmt.Errorf("t %d >= s %d", best.offset, s))
+                }
+                // Bail if we exceed the maximum size.
+                if d+(s-nextEmit) > dstLimit {
+                        return 0
+                }
+
+                base := s
+                offset := s - best.offset
+
+                s += best.length
+
+                if offset > 65535 && s-base <= 5 {
+                        // Bail if the match is equal or worse to the encoding.
+                        s = best.s + 1
+                        if s >= sLimit {
+                                goto emitRemainder
+                        }
+                        cv = load64(src, s)
+                        continue
+                }
+                d += emitLiteral(dst[d:], src[nextEmit:base])
+                d += emitCopyNoRepeat(dst[d:], offset, best.length)
+                repeat = offset
+
+                nextEmit = s
+                if s >= sLimit {
+                        goto emitRemainder
+                }
+
+                if d > dstLimit {
+                        // Do we have space for more, if not bail.
+                        return 0
+                }
+                // Fill tables...
+                for i := best.s + 1; i < s; i++ {
+                        cv0 := load64(src, i)
+                        long0 := hash8(cv0, lTableBits)
+                        short0 := hash4(cv0, sTableBits)
+                        lTable[long0] = uint64(i) | lTable[long0]<<32
+                        sTable[short0] = uint64(i) | sTable[short0]<<32
+                }
+                cv = load64(src, s)
+        }
+
+emitRemainder:
+        if nextEmit < len(src) {
+                // Bail if we exceed the maximum size.
+                if d+len(src)-nextEmit > dstLimit {
+                        return 0
+                }
+                d += emitLiteral(dst[d:], src[nextEmit:])
+        }
+        return d
+}
+
+// emitCopySize returns the size to encode the offset+length
+//
+// It assumes that:
+//
+//      1 <= offset && offset <= math.MaxUint32
+//      4 <= length && length <= 1 << 24
+func emitCopySize(offset, length int) int {
+        if offset >= 65536 {
+                i := 0
+                if length > 64 {
+                        length -= 64
+                        if length >= 4 {
+                                // Emit remaining as repeats
+                                return 5 + emitRepeatSize(offset, length)
+                        }
+                        i = 5
+                }
+                if length == 0 {
+                        return i
+                }
+                return i + 5
+        }
+
+        // Offset no more than 2 bytes.
+        if length > 64 {
+                if offset < 2048 {
+                        // Emit 8 bytes, then rest as repeats...
+                        return 2 + emitRepeatSize(offset, length-8)
+                }
+                // Emit remaining as repeats, at least 4 bytes remain.
+                return 3 + emitRepeatSize(offset, length-60)
+        }
+        if length >= 12 || offset >= 2048 {
+                return 3
+        }
+        // Emit the remaining copy, encoded as 2 bytes.
+        return 2
+}
+
+// emitCopyNoRepeatSize returns the size to encode the offset+length
+//
+// It assumes that:
+//
+//      1 <= offset && offset <= math.MaxUint32
+//      4 <= length && length <= 1 << 24
+func emitCopyNoRepeatSize(offset, length int) int {
+        if offset >= 65536 {
+                return 5 + 5*(length/64)
+        }
+
+        // Offset no more than 2 bytes.
+        if length > 64 {
+                // Emit remaining as repeats, at least 4 bytes remain.
+                return 3 + 3*(length/60)
+        }
+        if length >= 12 || offset >= 2048 {
+                return 3
+        }
+        // Emit the remaining copy, encoded as 2 bytes.
+        return 2
+}
+
+// emitRepeatSize returns the number of bytes required to encode a repeat.
+// Length must be at least 4 and < 1<<24
+func emitRepeatSize(offset, length int) int {
+        // Repeat offset, make length cheaper
+        if length <= 4+4 || (length < 8+4 && offset < 2048) {
+                return 2
+        }
+        if length < (1<<8)+4+4 {
+                return 3
+        }
+        if length < (1<<16)+(1<<8)+4 {
+                return 4
+        }
+        const maxRepeat = (1 << 24) - 1
+        length -= (1 << 16) - 4
+        left := 0
+        if length > maxRepeat {
+                left = length - maxRepeat + 4
+        }
+        if left > 0 {
+                return 5 + emitRepeatSize(offset, left)
+        }
+        return 5
+}
diff --git a/vendor/github.com/klauspost/compress/s2/encode_better.go b/vendor/github.com/klauspost/compress/s2/encode_better.go
new file mode 100644
index 0000000..544cb1e
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/encode_better.go
@@ -0,0 +1,1106 @@
+// Copyright 2016 The Snappy-Go Authors. All rights reserved.
+// Copyright (c) 2019 Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s2
+
+import (
+        "bytes"
+        "fmt"
+        "math/bits"
+)
+
+// hash4 returns the hash of the lowest 4 bytes of u to fit in a hash table with h bits.
+// Preferably h should be a constant and should always be <32.
+func hash4(u uint64, h uint8) uint32 {
+        const prime4bytes = 2654435761
+        return (uint32(u) * prime4bytes) >> ((32 - h) & 31)
+}
+
+// hash5 returns the hash of the lowest 5 bytes of u to fit in a hash table with h bits.
+// Preferably h should be a constant and should always be <64.
+func hash5(u uint64, h uint8) uint32 {
+        const prime5bytes = 889523592379
+        return uint32(((u << (64 - 40)) * prime5bytes) >> ((64 - h) & 63))
+}
+
+// hash7 returns the hash of the lowest 7 bytes of u to fit in a hash table with h bits.
+// Preferably h should be a constant and should always be <64.
+func hash7(u uint64, h uint8) uint32 {
+        const prime7bytes = 58295818150454627
+        return uint32(((u << (64 - 56)) * prime7bytes) >> ((64 - h) & 63))
+}
+
+// hash8 returns the hash of u to fit in a hash table with h bits.
+// Preferably h should be a constant and should always be <64.
+func hash8(u uint64, h uint8) uint32 {
+        const prime8bytes = 0xcf1bbcdcb7a56463
+        return uint32((u * prime8bytes) >> ((64 - h) & 63))
+}
+
+// encodeBlockBetter encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src)) &&
+//      minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
+func encodeBlockBetterGo(dst, src []byte) (d int) {
+        // sLimit is when to stop looking for offset/length copies. The inputMargin
+        // lets us use a fast path for emitLiteral in the main loop, while we are
+        // looking for copies.
+        sLimit := len(src) - inputMargin
+        if len(src) < minNonLiteralBlockSize {
+                return 0
+        }
+
+        // Initialize the hash tables.
+        const (
+                // Long hash matches.
+                lTableBits    = 17
+                maxLTableSize = 1 << lTableBits
+
+                // Short hash matches.
+                sTableBits    = 14
+                maxSTableSize = 1 << sTableBits
+        )
+
+        var lTable [maxLTableSize]uint32
+        var sTable [maxSTableSize]uint32
+
+        // Bail if we can't compress to at least this.
+        dstLimit := len(src) - len(src)>>5 - 6
+
+        // nextEmit is where in src the next emitLiteral should start from.
+        nextEmit := 0
+
+        // The encoded form must start with a literal, as there are no previous
+        // bytes to copy, so we start looking for hash matches at s == 1.
+        s := 1
+        cv := load64(src, s)
+
+        // We initialize repeat to 0, so we never match on first attempt
+        repeat := 0
+
+        for {
+                candidateL := 0
+                nextS := 0
+                for {
+                        // Next src position to check
+                        nextS = s + (s-nextEmit)>>7 + 1
+                        if nextS > sLimit {
+                                goto emitRemainder
+                        }
+                        hashL := hash7(cv, lTableBits)
+                        hashS := hash4(cv, sTableBits)
+                        candidateL = int(lTable[hashL])
+                        candidateS := int(sTable[hashS])
+                        lTable[hashL] = uint32(s)
+                        sTable[hashS] = uint32(s)
+
+                        valLong := load64(src, candidateL)
+                        valShort := load64(src, candidateS)
+
+                        // If long matches at least 8 bytes, use that.
+                        if cv == valLong {
+                                break
+                        }
+                        if cv == valShort {
+                                candidateL = candidateS
+                                break
+                        }
+
+                        // Check repeat at offset checkRep.
+                        const checkRep = 1
+                        // Minimum length of a repeat. Tested with various values.
+                        // While 4-5 offers improvements in some, 6 reduces
+                        // regressions significantly.
+                        const wantRepeatBytes = 6
+                        const repeatMask = ((1 << (wantRepeatBytes * 8)) - 1) << (8 * checkRep)
+                        if false && repeat > 0 && cv&repeatMask == load64(src, s-repeat)&repeatMask {
+                                base := s + checkRep
+                                // Extend back
+                                for i := base - repeat; base > nextEmit && i > 0 && src[i-1] == src[base-1]; {
+                                        i--
+                                        base--
+                                }
+                                d += emitLiteral(dst[d:], src[nextEmit:base])
+
+                                // Extend forward
+                                candidate := s - repeat + wantRepeatBytes + checkRep
+                                s += wantRepeatBytes + checkRep
+                                for s < len(src) {
+                                        if len(src)-s < 8 {
+                                                if src[s] == src[candidate] {
+                                                        s++
+                                                        candidate++
+                                                        continue
+                                                }
+                                                break
+                                        }
+                                        if diff := load64(src, s) ^ load64(src, candidate); diff != 0 {
+                                                s += bits.TrailingZeros64(diff) >> 3
+                                                break
+                                        }
+                                        s += 8
+                                        candidate += 8
+                                }
+                                // same as `add := emitCopy(dst[d:], repeat, s-base)` but skips storing offset.
+                                d += emitRepeat(dst[d:], repeat, s-base)
+                                nextEmit = s
+                                if s >= sLimit {
+                                        goto emitRemainder
+                                }
+                                // Index in-between
+                                index0 := base + 1
+                                index1 := s - 2
+
+                                for index0 < index1 {
+                                        cv0 := load64(src, index0)
+                                        cv1 := load64(src, index1)
+                                        lTable[hash7(cv0, lTableBits)] = uint32(index0)
+                                        sTable[hash4(cv0>>8, sTableBits)] = uint32(index0 + 1)
+
+                                        lTable[hash7(cv1, lTableBits)] = uint32(index1)
+                                        sTable[hash4(cv1>>8, sTableBits)] = uint32(index1 + 1)
+                                        index0 += 2
+                                        index1 -= 2
+                                }
+
+                                cv = load64(src, s)
+                                continue
+                        }
+
+                        // Long likely matches 7, so take that.
+                        if uint32(cv) == uint32(valLong) {
+                                break
+                        }
+
+                        // Check our short candidate
+                        if uint32(cv) == uint32(valShort) {
+                                // Try a long candidate at s+1
+                                hashL = hash7(cv>>8, lTableBits)
+                                candidateL = int(lTable[hashL])
+                                lTable[hashL] = uint32(s + 1)
+                                if uint32(cv>>8) == load32(src, candidateL) {
+                                        s++
+                                        break
+                                }
+                                // Use our short candidate.
+                                candidateL = candidateS
+                                break
+                        }
+
+                        cv = load64(src, nextS)
+                        s = nextS
+                }
+
+                // Extend backwards
+                for candidateL > 0 && s > nextEmit && src[candidateL-1] == src[s-1] {
+                        candidateL--
+                        s--
+                }
+
+                // Bail if we exceed the maximum size.
+                if d+(s-nextEmit) > dstLimit {
+                        return 0
+                }
+
+                base := s
+                offset := base - candidateL
+
+                // Extend the 4-byte match as long as possible.
+                s += 4
+                candidateL += 4
+                for s < len(src) {
+                        if len(src)-s < 8 {
+                                if src[s] == src[candidateL] {
+                                        s++
+                                        candidateL++
+                                        continue
+                                }
+                                break
+                        }
+                        if diff := load64(src, s) ^ load64(src, candidateL); diff != 0 {
+                                s += bits.TrailingZeros64(diff) >> 3
+                                break
+                        }
+                        s += 8
+                        candidateL += 8
+                }
+
+                if offset > 65535 && s-base <= 5 && repeat != offset {
+                        // Bail if the match is equal or worse to the encoding.
+                        s = nextS + 1
+                        if s >= sLimit {
+                                goto emitRemainder
+                        }
+                        cv = load64(src, s)
+                        continue
+                }
+
+                d += emitLiteral(dst[d:], src[nextEmit:base])
+                if repeat == offset {
+                        d += emitRepeat(dst[d:], offset, s-base)
+                } else {
+                        d += emitCopy(dst[d:], offset, s-base)
+                        repeat = offset
+                }
+
+                nextEmit = s
+                if s >= sLimit {
+                        goto emitRemainder
+                }
+
+                if d > dstLimit {
+                        // Do we have space for more, if not bail.
+                        return 0
+                }
+
+                // Index short & long
+                index0 := base + 1
+                index1 := s - 2
+
+                cv0 := load64(src, index0)
+                cv1 := load64(src, index1)
+                lTable[hash7(cv0, lTableBits)] = uint32(index0)
+                sTable[hash4(cv0>>8, sTableBits)] = uint32(index0 + 1)
+
+                // lTable could be postponed, but very minor difference.
+                lTable[hash7(cv1, lTableBits)] = uint32(index1)
+                sTable[hash4(cv1>>8, sTableBits)] = uint32(index1 + 1)
+                index0 += 1
+                index1 -= 1
+                cv = load64(src, s)
+
+                // Index large values sparsely in between.
+                // We do two starting from different offsets for speed.
+                index2 := (index0 + index1 + 1) >> 1
+                for index2 < index1 {
+                        lTable[hash7(load64(src, index0), lTableBits)] = uint32(index0)
+                        lTable[hash7(load64(src, index2), lTableBits)] = uint32(index2)
+                        index0 += 2
+                        index2 += 2
+                }
+        }
+
+emitRemainder:
+        if nextEmit < len(src) {
+                // Bail if we exceed the maximum size.
+                if d+len(src)-nextEmit > dstLimit {
+                        return 0
+                }
+                d += emitLiteral(dst[d:], src[nextEmit:])
+        }
+        return d
+}
+
+// encodeBlockBetterSnappyGo encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src)) &&
+//      minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
+func encodeBlockBetterSnappyGo(dst, src []byte) (d int) {
+        // sLimit is when to stop looking for offset/length copies. The inputMargin
+        // lets us use a fast path for emitLiteral in the main loop, while we are
+        // looking for copies.
+        sLimit := len(src) - inputMargin
+        if len(src) < minNonLiteralBlockSize {
+                return 0
+        }
+
+        // Initialize the hash tables.
+        const (
+                // Long hash matches.
+                lTableBits    = 16
+                maxLTableSize = 1 << lTableBits
+
+                // Short hash matches.
+                sTableBits    = 14
+                maxSTableSize = 1 << sTableBits
+        )
+
+        var lTable [maxLTableSize]uint32
+        var sTable [maxSTableSize]uint32
+
+        // Bail if we can't compress to at least this.
+        dstLimit := len(src) - len(src)>>5 - 6
+
+        // nextEmit is where in src the next emitLiteral should start from.
+        nextEmit := 0
+
+        // The encoded form must start with a literal, as there are no previous
+        // bytes to copy, so we start looking for hash matches at s == 1.
+        s := 1
+        cv := load64(src, s)
+
+        // We initialize repeat to 0, so we never match on first attempt
+        repeat := 0
+        const maxSkip = 100
+
+        for {
+                candidateL := 0
+                nextS := 0
+                for {
+                        // Next src position to check
+                        nextS = (s-nextEmit)>>7 + 1
+                        if nextS > maxSkip {
+                                nextS = s + maxSkip
+                        } else {
+                                nextS += s
+                        }
+
+                        if nextS > sLimit {
+                                goto emitRemainder
+                        }
+                        hashL := hash7(cv, lTableBits)
+                        hashS := hash4(cv, sTableBits)
+                        candidateL = int(lTable[hashL])
+                        candidateS := int(sTable[hashS])
+                        lTable[hashL] = uint32(s)
+                        sTable[hashS] = uint32(s)
+
+                        if uint32(cv) == load32(src, candidateL) {
+                                break
+                        }
+
+                        // Check our short candidate
+                        if uint32(cv) == load32(src, candidateS) {
+                                // Try a long candidate at s+1
+                                hashL = hash7(cv>>8, lTableBits)
+                                candidateL = int(lTable[hashL])
+                                lTable[hashL] = uint32(s + 1)
+                                if uint32(cv>>8) == load32(src, candidateL) {
+                                        s++
+                                        break
+                                }
+                                // Use our short candidate.
+                                candidateL = candidateS
+                                break
+                        }
+
+                        cv = load64(src, nextS)
+                        s = nextS
+                }
+
+                // Extend backwards
+                for candidateL > 0 && s > nextEmit && src[candidateL-1] == src[s-1] {
+                        candidateL--
+                        s--
+                }
+
+                // Bail if we exceed the maximum size.
+                if d+(s-nextEmit) > dstLimit {
+                        return 0
+                }
+
+                base := s
+                offset := base - candidateL
+
+                // Extend the 4-byte match as long as possible.
+                s += 4
+                candidateL += 4
+                for s < len(src) {
+                        if len(src)-s < 8 {
+                                if src[s] == src[candidateL] {
+                                        s++
+                                        candidateL++
+                                        continue
+                                }
+                                break
+                        }
+                        if diff := load64(src, s) ^ load64(src, candidateL); diff != 0 {
+                                s += bits.TrailingZeros64(diff) >> 3
+                                break
+                        }
+                        s += 8
+                        candidateL += 8
+                }
+
+                if offset > 65535 && s-base <= 5 && repeat != offset {
+                        // Bail if the match is equal or worse to the encoding.
+                        s = nextS + 1
+                        if s >= sLimit {
+                                goto emitRemainder
+                        }
+                        cv = load64(src, s)
+                        continue
+                }
+
+                d += emitLiteral(dst[d:], src[nextEmit:base])
+                d += emitCopyNoRepeat(dst[d:], offset, s-base)
+                repeat = offset
+
+                nextEmit = s
+                if s >= sLimit {
+                        goto emitRemainder
+                }
+
+                if d > dstLimit {
+                        // Do we have space for more, if not bail.
+                        return 0
+                }
+
+                // Index short & long
+                index0 := base + 1
+                index1 := s - 2
+
+                cv0 := load64(src, index0)
+                cv1 := load64(src, index1)
+                lTable[hash7(cv0, lTableBits)] = uint32(index0)
+                sTable[hash4(cv0>>8, sTableBits)] = uint32(index0 + 1)
+
+                lTable[hash7(cv1, lTableBits)] = uint32(index1)
+                sTable[hash4(cv1>>8, sTableBits)] = uint32(index1 + 1)
+                index0 += 1
+                index1 -= 1
+                cv = load64(src, s)
+
+                // Index large values sparsely in between.
+                // We do two starting from different offsets for speed.
+                index2 := (index0 + index1 + 1) >> 1
+                for index2 < index1 {
+                        lTable[hash7(load64(src, index0), lTableBits)] = uint32(index0)
+                        lTable[hash7(load64(src, index2), lTableBits)] = uint32(index2)
+                        index0 += 2
+                        index2 += 2
+                }
+        }
+
+emitRemainder:
+        if nextEmit < len(src) {
+                // Bail if we exceed the maximum size.
+                if d+len(src)-nextEmit > dstLimit {
+                        return 0
+                }
+                d += emitLiteral(dst[d:], src[nextEmit:])
+        }
+        return d
+}
+
+// encodeBlockBetterDict encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src)) &&
+//      minNonLiteralBlockSize <= len(src) && len(src) <= maxBlockSize
+func encodeBlockBetterDict(dst, src []byte, dict *Dict) (d int) {
+        // sLimit is when to stop looking for offset/length copies. The inputMargin
+        // lets us use a fast path for emitLiteral in the main loop, while we are
+        // looking for copies.
+        // Initialize the hash tables.
+        const (
+                // Long hash matches.
+                lTableBits    = 17
+                maxLTableSize = 1 << lTableBits
+
+                // Short hash matches.
+                sTableBits    = 14
+                maxSTableSize = 1 << sTableBits
+
+                maxAhead = 8 // maximum bytes ahead without checking sLimit
+
+                debug = false
+        )
+
+        sLimit := len(src) - inputMargin
+        if sLimit > MaxDictSrcOffset-maxAhead {
+                sLimit = MaxDictSrcOffset - maxAhead
+        }
+        if len(src) < minNonLiteralBlockSize {
+                return 0
+        }
+
+        dict.initBetter()
+
+        var lTable [maxLTableSize]uint32
+        var sTable [maxSTableSize]uint32
+
+        // Bail if we can't compress to at least this.
+        dstLimit := len(src) - len(src)>>5 - 6
+
+        // nextEmit is where in src the next emitLiteral should start from.
+        nextEmit := 0
+
+        // The encoded form must start with a literal, as there are no previous
+        // bytes to copy, so we start looking for hash matches at s == 1.
+        s := 0
+        cv := load64(src, s)
+
+        // We initialize repeat to 0, so we never match on first attempt
+        repeat := len(dict.dict) - dict.repeat
+
+        // While in dict
+searchDict:
+        for {
+                candidateL := 0
+                nextS := 0
+                for {
+                        // Next src position to check
+                        nextS = s + (s-nextEmit)>>7 + 1
+                        if nextS > sLimit {
+                                break searchDict
+                        }
+                        hashL := hash7(cv, lTableBits)
+                        hashS := hash4(cv, sTableBits)
+                        candidateL = int(lTable[hashL])
+                        candidateS := int(sTable[hashS])
+                        dictL := int(dict.betterTableLong[hashL])
+                        dictS := int(dict.betterTableShort[hashS])
+                        lTable[hashL] = uint32(s)
+                        sTable[hashS] = uint32(s)
+
+                        valLong := load64(src, candidateL)
+                        valShort := load64(src, candidateS)
+
+                        // If long matches at least 8 bytes, use that.
+                        if s != 0 {
+                                if cv == valLong {
+                                        goto emitMatch
+                                }
+                                if cv == valShort {
+                                        candidateL = candidateS
+                                        goto emitMatch
+                                }
+                        }
+
+                        // Check dict repeat.
+                        if repeat >= s+4 {
+                                candidate := len(dict.dict) - repeat + s
+                                if candidate > 0 && uint32(cv) == load32(dict.dict, candidate) {
+                                        // Extend back
+                                        base := s
+                                        for i := candidate; base > nextEmit && i > 0 && dict.dict[i-1] == src[base-1]; {
+                                                i--
+                                                base--
+                                        }
+                                        d += emitLiteral(dst[d:], src[nextEmit:base])
+                                        if debug && nextEmit != base {
+                                                fmt.Println("emitted ", base-nextEmit, "literals")
+                                        }
+                                        s += 4
+                                        candidate += 4
+                                        for candidate < len(dict.dict)-8 && s <= len(src)-8 {
+                                                if diff := load64(src, s) ^ load64(dict.dict, candidate); diff != 0 {
+                                                        s += bits.TrailingZeros64(diff) >> 3
+                                                        break
+                                                }
+                                                s += 8
+                                                candidate += 8
+                                        }
+                                        d += emitRepeat(dst[d:], repeat, s-base)
+                                        if debug {
+                                                fmt.Println("emitted dict repeat length", s-base, "offset:", repeat, "s:", s)
+                                        }
+                                        nextEmit = s
+                                        if s >= sLimit {
+                                                break searchDict
+                                        }
+                                        // Index in-between
+                                        index0 := base + 1
+                                        index1 := s - 2
+
+                                        cv = load64(src, s)
+                                        for index0 < index1 {
+                                                cv0 := load64(src, index0)
+                                                cv1 := load64(src, index1)
+                                                lTable[hash7(cv0, lTableBits)] = uint32(index0)
+                                                sTable[hash4(cv0>>8, sTableBits)] = uint32(index0 + 1)
+
+                                                lTable[hash7(cv1, lTableBits)] = uint32(index1)
+                                                sTable[hash4(cv1>>8, sTableBits)] = uint32(index1 + 1)
+                                                index0 += 2
+                                                index1 -= 2
+                                        }
+                                        continue
+                                }
+                        }
+                        // Don't try to find match at s==0
+                        if s == 0 {
+                                cv = load64(src, nextS)
+                                s = nextS
+                                continue
+                        }
+
+                        // Long likely matches 7, so take that.
+                        if uint32(cv) == uint32(valLong) {
+                                goto emitMatch
+                        }
+
+                        // Long dict...
+                        if uint32(cv) == load32(dict.dict, dictL) {
+                                candidateL = dictL
+                                goto emitDict
+                        }
+
+                        // Check our short candidate
+                        if uint32(cv) == uint32(valShort) {
+                                // Try a long candidate at s+1
+                                hashL = hash7(cv>>8, lTableBits)
+                                candidateL = int(lTable[hashL])
+                                lTable[hashL] = uint32(s + 1)
+                                if uint32(cv>>8) == load32(src, candidateL) {
+                                        s++
+                                        goto emitMatch
+                                }
+                                // Use our short candidate.
+                                candidateL = candidateS
+                                goto emitMatch
+                        }
+                        if uint32(cv) == load32(dict.dict, dictS) {
+                                // Try a long candidate at s+1
+                                hashL = hash7(cv>>8, lTableBits)
+                                candidateL = int(lTable[hashL])
+                                lTable[hashL] = uint32(s + 1)
+                                if uint32(cv>>8) == load32(src, candidateL) {
+                                        s++
+                                        goto emitMatch
+                                }
+                                candidateL = dictS
+                                goto emitDict
+                        }
+                        cv = load64(src, nextS)
+                        s = nextS
+                }
+        emitDict:
+                {
+                        if debug {
+                                if load32(dict.dict, candidateL) != load32(src, s) {
+                                        panic("dict emit mismatch")
+                                }
+                        }
+                        // Extend backwards.
+                        // The top bytes will be rechecked to get the full match.
+                        for candidateL > 0 && s > nextEmit && dict.dict[candidateL-1] == src[s-1] {
+                                candidateL--
+                                s--
+                        }
+
+                        // Bail if we exceed the maximum size.
+                        if d+(s-nextEmit) > dstLimit {
+                                return 0
+                        }
+
+                        // A 4-byte match has been found. We'll later see if more than 4 bytes
+                        // match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
+                        // them as literal bytes.
+
+                        d += emitLiteral(dst[d:], src[nextEmit:s])
+                        if debug && nextEmit != s {
+                                fmt.Println("emitted ", s-nextEmit, "literals")
+                        }
+                        {
+                                // Invariant: we have a 4-byte match at s, and no need to emit any
+                                // literal bytes prior to s.
+                                base := s
+                                offset := s + (len(dict.dict)) - candidateL
+
+                                // Extend the 4-byte match as long as possible.
+                                s += 4
+                                candidateL += 4
+                                for s <= len(src)-8 && len(dict.dict)-candidateL >= 8 {
+                                        if diff := load64(src, s) ^ load64(dict.dict, candidateL); diff != 0 {
+                                                s += bits.TrailingZeros64(diff) >> 3
+                                                break
+                                        }
+                                        s += 8
+                                        candidateL += 8
+                                }
+
+                                if repeat == offset {
+                                        if debug {
+                                                fmt.Println("emitted dict repeat, length", s-base, "offset:", offset, "s:", s, "dict offset:", candidateL)
+                                        }
+                                        d += emitRepeat(dst[d:], offset, s-base)
+                                } else {
+                                        if debug {
+                                                fmt.Println("emitted dict copy, length", s-base, "offset:", offset, "s:", s, "dict offset:", candidateL)
+                                        }
+                                        // Matches longer than 64 are split.
+                                        if s <= sLimit || s-base < 8 {
+                                                d += emitCopy(dst[d:], offset, s-base)
+                                        } else {
+                                                // Split to ensure we don't start a copy within next block.
+                                                d += emitCopy(dst[d:], offset, 4)
+                                                d += emitRepeat(dst[d:], offset, s-base-4)
+                                        }
+                                        repeat = offset
+                                }
+                                if false {
+                                        // Validate match.
+                                        if s <= candidateL {
+                                                panic("s <= candidate")
+                                        }
+                                        a := src[base:s]
+                                        b := dict.dict[base-repeat : base-repeat+(s-base)]
+                                        if !bytes.Equal(a, b) {
+                                                panic("mismatch")
+                                        }
+                                }
+
+                                nextEmit = s
+                                if s >= sLimit {
+                                        break searchDict
+                                }
+
+                                if d > dstLimit {
+                                        // Do we have space for more, if not bail.
+                                        return 0
+                                }
+
+                                // Index short & long
+                                index0 := base + 1
+                                index1 := s - 2
+
+                                cv0 := load64(src, index0)
+                                cv1 := load64(src, index1)
+                                lTable[hash7(cv0, lTableBits)] = uint32(index0)
+                                sTable[hash4(cv0>>8, sTableBits)] = uint32(index0 + 1)
+
+                                lTable[hash7(cv1, lTableBits)] = uint32(index1)
+                                sTable[hash4(cv1>>8, sTableBits)] = uint32(index1 + 1)
+                                index0 += 1
+                                index1 -= 1
+                                cv = load64(src, s)
+
+                                // index every second long in between.
+                                for index0 < index1 {
+                                        lTable[hash7(load64(src, index0), lTableBits)] = uint32(index0)
+                                        lTable[hash7(load64(src, index1), lTableBits)] = uint32(index1)
+                                        index0 += 2
+                                        index1 -= 2
+                                }
+                        }
+                        continue
+                }
+        emitMatch:
+
+                // Extend backwards
+                for candidateL > 0 && s > nextEmit && src[candidateL-1] == src[s-1] {
+                        candidateL--
+                        s--
+                }
+
+                // Bail if we exceed the maximum size.
+                if d+(s-nextEmit) > dstLimit {
+                        return 0
+                }
+
+                base := s
+                offset := base - candidateL
+
+                // Extend the 4-byte match as long as possible.
+                s += 4
+                candidateL += 4
+                for s < len(src) {
+                        if len(src)-s < 8 {
+                                if src[s] == src[candidateL] {
+                                        s++
+                                        candidateL++
+                                        continue
+                                }
+                                break
+                        }
+                        if diff := load64(src, s) ^ load64(src, candidateL); diff != 0 {
+                                s += bits.TrailingZeros64(diff) >> 3
+                                break
+                        }
+                        s += 8
+                        candidateL += 8
+                }
+
+                if offset > 65535 && s-base <= 5 && repeat != offset {
+                        // Bail if the match is equal or worse to the encoding.
+                        s = nextS + 1
+                        if s >= sLimit {
+                                goto emitRemainder
+                        }
+                        cv = load64(src, s)
+                        continue
+                }
+
+                d += emitLiteral(dst[d:], src[nextEmit:base])
+                if debug && nextEmit != s {
+                        fmt.Println("emitted ", s-nextEmit, "literals")
+                }
+                if repeat == offset {
+                        if debug {
+                                fmt.Println("emitted match repeat, length", s-base, "offset:", offset, "s:", s)
+                        }
+                        d += emitRepeat(dst[d:], offset, s-base)
+                } else {
+                        if debug {
+                                fmt.Println("emitted match copy, length", s-base, "offset:", offset, "s:", s)
+                        }
+                        d += emitCopy(dst[d:], offset, s-base)
+                        repeat = offset
+                }
+
+                nextEmit = s
+                if s >= sLimit {
+                        goto emitRemainder
+                }
+
+                if d > dstLimit {
+                        // Do we have space for more, if not bail.
+                        return 0
+                }
+
+                // Index short & long
+                index0 := base + 1
+                index1 := s - 2
+
+                cv0 := load64(src, index0)
+                cv1 := load64(src, index1)
+                lTable[hash7(cv0, lTableBits)] = uint32(index0)
+                sTable[hash4(cv0>>8, sTableBits)] = uint32(index0 + 1)
+
+                lTable[hash7(cv1, lTableBits)] = uint32(index1)
+                sTable[hash4(cv1>>8, sTableBits)] = uint32(index1 + 1)
+                index0 += 1
+                index1 -= 1
+                cv = load64(src, s)
+
+                // Index large values sparsely in between.
+                // We do two starting from different offsets for speed.
+                index2 := (index0 + index1 + 1) >> 1
+                for index2 < index1 {
+                        lTable[hash7(load64(src, index0), lTableBits)] = uint32(index0)
+                        lTable[hash7(load64(src, index2), lTableBits)] = uint32(index2)
+                        index0 += 2
+                        index2 += 2
+                }
+        }
+
+        // Search without dict:
+        if repeat > s {
+                repeat = 0
+        }
+
+        // No more dict
+        sLimit = len(src) - inputMargin
+        if s >= sLimit {
+                goto emitRemainder
+        }
+        cv = load64(src, s)
+        if debug {
+                fmt.Println("now", s, "->", sLimit, "out:", d, "left:", len(src)-s, "nextemit:", nextEmit, "dstLimit:", dstLimit, "s:", s)
+        }
+        for {
+                candidateL := 0
+                nextS := 0
+                for {
+                        // Next src position to check
+                        nextS = s + (s-nextEmit)>>7 + 1
+                        if nextS > sLimit {
+                                goto emitRemainder
+                        }
+                        hashL := hash7(cv, lTableBits)
+                        hashS := hash4(cv, sTableBits)
+                        candidateL = int(lTable[hashL])
+                        candidateS := int(sTable[hashS])
+                        lTable[hashL] = uint32(s)
+                        sTable[hashS] = uint32(s)
+
+                        valLong := load64(src, candidateL)
+                        valShort := load64(src, candidateS)
+
+                        // If long matches at least 8 bytes, use that.
+                        if cv == valLong {
+                                break
+                        }
+                        if cv == valShort {
+                                candidateL = candidateS
+                                break
+                        }
+
+                        // Check repeat at offset checkRep.
+                        const checkRep = 1
+                        // Minimum length of a repeat. Tested with various values.
+                        // While 4-5 offers improvements in some, 6 reduces
+                        // regressions significantly.
+                        const wantRepeatBytes = 6
+                        const repeatMask = ((1 << (wantRepeatBytes * 8)) - 1) << (8 * checkRep)
+                        if false && repeat > 0 && cv&repeatMask == load64(src, s-repeat)&repeatMask {
+                                base := s + checkRep
+                                // Extend back
+                                for i := base - repeat; base > nextEmit && i > 0 && src[i-1] == src[base-1]; {
+                                        i--
+                                        base--
+                                }
+                                d += emitLiteral(dst[d:], src[nextEmit:base])
+
+                                // Extend forward
+                                candidate := s - repeat + wantRepeatBytes + checkRep
+                                s += wantRepeatBytes + checkRep
+                                for s < len(src) {
+                                        if len(src)-s < 8 {
+                                                if src[s] == src[candidate] {
+                                                        s++
+                                                        candidate++
+                                                        continue
+                                                }
+                                                break
+                                        }
+                                        if diff := load64(src, s) ^ load64(src, candidate); diff != 0 {
+                                                s += bits.TrailingZeros64(diff) >> 3
+                                                break
+                                        }
+                                        s += 8
+                                        candidate += 8
+                                }
+                                // same as `add := emitCopy(dst[d:], repeat, s-base)` but skips storing offset.
+                                d += emitRepeat(dst[d:], repeat, s-base)
+                                nextEmit = s
+                                if s >= sLimit {
+                                        goto emitRemainder
+                                }
+                                // Index in-between
+                                index0 := base + 1
+                                index1 := s - 2
+
+                                for index0 < index1 {
+                                        cv0 := load64(src, index0)
+                                        cv1 := load64(src, index1)
+                                        lTable[hash7(cv0, lTableBits)] = uint32(index0)
+                                        sTable[hash4(cv0>>8, sTableBits)] = uint32(index0 + 1)
+
+                                        lTable[hash7(cv1, lTableBits)] = uint32(index1)
+                                        sTable[hash4(cv1>>8, sTableBits)] = uint32(index1 + 1)
+                                        index0 += 2
+                                        index1 -= 2
+                                }
+
+                                cv = load64(src, s)
+                                continue
+                        }
+
+                        // Long likely matches 7, so take that.
+                        if uint32(cv) == uint32(valLong) {
+                                break
+                        }
+
+                        // Check our short candidate
+                        if uint32(cv) == uint32(valShort) {
+                                // Try a long candidate at s+1
+                                hashL = hash7(cv>>8, lTableBits)
+                                candidateL = int(lTable[hashL])
+                                lTable[hashL] = uint32(s + 1)
+                                if uint32(cv>>8) == load32(src, candidateL) {
+                                        s++
+                                        break
+                                }
+                                // Use our short candidate.
+                                candidateL = candidateS
+                                break
+                        }
+
+                        cv = load64(src, nextS)
+                        s = nextS
+                }
+
+                // Extend backwards
+                for candidateL > 0 && s > nextEmit && src[candidateL-1] == src[s-1] {
+                        candidateL--
+                        s--
+                }
+
+                // Bail if we exceed the maximum size.
+                if d+(s-nextEmit) > dstLimit {
+                        return 0
+                }
+
+                base := s
+                offset := base - candidateL
+
+                // Extend the 4-byte match as long as possible.
+                s += 4
+                candidateL += 4
+                for s < len(src) {
+                        if len(src)-s < 8 {
+                                if src[s] == src[candidateL] {
+                                        s++
+                                        candidateL++
+                                        continue
+                                }
+                                break
+                        }
+                        if diff := load64(src, s) ^ load64(src, candidateL); diff != 0 {
+                                s += bits.TrailingZeros64(diff) >> 3
+                                break
+                        }
+                        s += 8
+                        candidateL += 8
+                }
+
+                if offset > 65535 && s-base <= 5 && repeat != offset {
+                        // Bail if the match is equal or worse to the encoding.
+                        s = nextS + 1
+                        if s >= sLimit {
+                                goto emitRemainder
+                        }
+                        cv = load64(src, s)
+                        continue
+                }
+
+                d += emitLiteral(dst[d:], src[nextEmit:base])
+                if repeat == offset {
+                        d += emitRepeat(dst[d:], offset, s-base)
+                } else {
+                        d += emitCopy(dst[d:], offset, s-base)
+                        repeat = offset
+                }
+
+                nextEmit = s
+                if s >= sLimit {
+                        goto emitRemainder
+                }
+
+                if d > dstLimit {
+                        // Do we have space for more, if not bail.
+                        return 0
+                }
+
+                // Index short & long
+                index0 := base + 1
+                index1 := s - 2
+
+                cv0 := load64(src, index0)
+                cv1 := load64(src, index1)
+                lTable[hash7(cv0, lTableBits)] = uint32(index0)
+                sTable[hash4(cv0>>8, sTableBits)] = uint32(index0 + 1)
+
+                lTable[hash7(cv1, lTableBits)] = uint32(index1)
+                sTable[hash4(cv1>>8, sTableBits)] = uint32(index1 + 1)
+                index0 += 1
+                index1 -= 1
+                cv = load64(src, s)
+
+                // Index large values sparsely in between.
+                // We do two starting from different offsets for speed.
+                index2 := (index0 + index1 + 1) >> 1
+                for index2 < index1 {
+                        lTable[hash7(load64(src, index0), lTableBits)] = uint32(index0)
+                        lTable[hash7(load64(src, index2), lTableBits)] = uint32(index2)
+                        index0 += 2
+                        index2 += 2
+                }
+        }
+
+emitRemainder:
+        if nextEmit < len(src) {
+                // Bail if we exceed the maximum size.
+                if d+len(src)-nextEmit > dstLimit {
+                        return 0
+                }
+                d += emitLiteral(dst[d:], src[nextEmit:])
+        }
+        return d
+}
diff --git a/vendor/github.com/klauspost/compress/s2/encode_go.go b/vendor/github.com/klauspost/compress/s2/encode_go.go
new file mode 100644
index 0000000..6b393c3
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/encode_go.go
@@ -0,0 +1,729 @@
+//go:build !amd64 || appengine || !gc || noasm
+// +build !amd64 appengine !gc noasm
+
+package s2
+
+import (
+        "bytes"
+        "math/bits"
+)
+
+const hasAmd64Asm = false
+
+// encodeBlock encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src))
+func encodeBlock(dst, src []byte) (d int) {
+        if len(src) < minNonLiteralBlockSize {
+                return 0
+        }
+        return encodeBlockGo(dst, src)
+}
+
+// encodeBlockBetter encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src))
+func encodeBlockBetter(dst, src []byte) (d int) {
+        return encodeBlockBetterGo(dst, src)
+}
+
+// encodeBlockBetter encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src))
+func encodeBlockBetterSnappy(dst, src []byte) (d int) {
+        return encodeBlockBetterSnappyGo(dst, src)
+}
+
+// encodeBlock encodes a non-empty src to a guaranteed-large-enough dst. It
+// assumes that the varint-encoded length of the decompressed bytes has already
+// been written.
+//
+// It also assumes that:
+//
+//      len(dst) >= MaxEncodedLen(len(src))
+func encodeBlockSnappy(dst, src []byte) (d int) {
+        if len(src) < minNonLiteralBlockSize {
+                return 0
+        }
+        return encodeBlockSnappyGo(dst, src)
+}
+
+// emitLiteral writes a literal chunk and returns the number of bytes written.
+//
+// It assumes that:
+//
+//      dst is long enough to hold the encoded bytes
+//      0 <= len(lit) && len(lit) <= math.MaxUint32
+func emitLiteral(dst, lit []byte) int {
+        if len(lit) == 0 {
+                return 0
+        }
+        const num = 63<<2 | tagLiteral
+        i, n := 0, uint(len(lit)-1)
+        switch {
+        case n < 60:
+                dst[0] = uint8(n)<<2 | tagLiteral
+                i = 1
+        case n < 1<<8:
+                dst[1] = uint8(n)
+                dst[0] = 60<<2 | tagLiteral
+                i = 2
+        case n < 1<<16:
+                dst[2] = uint8(n >> 8)
+                dst[1] = uint8(n)
+                dst[0] = 61<<2 | tagLiteral
+                i = 3
+        case n < 1<<24:
+                dst[3] = uint8(n >> 16)
+                dst[2] = uint8(n >> 8)
+                dst[1] = uint8(n)
+                dst[0] = 62<<2 | tagLiteral
+                i = 4
+        default:
+                dst[4] = uint8(n >> 24)
+                dst[3] = uint8(n >> 16)
+                dst[2] = uint8(n >> 8)
+                dst[1] = uint8(n)
+                dst[0] = 63<<2 | tagLiteral
+                i = 5
+        }
+        return i + copy(dst[i:], lit)
+}
+
+// emitRepeat writes a repeat chunk and returns the number of bytes written.
+// Length must be at least 4 and < 1<<24
+func emitRepeat(dst []byte, offset, length int) int {
+        // Repeat offset, make length cheaper
+        length -= 4
+        if length <= 4 {
+                dst[0] = uint8(length)<<2 | tagCopy1
+                dst[1] = 0
+                return 2
+        }
+        if length < 8 && offset < 2048 {
+                // Encode WITH offset
+                dst[1] = uint8(offset)
+                dst[0] = uint8(offset>>8)<<5 | uint8(length)<<2 | tagCopy1
+                return 2
+        }
+        if length < (1<<8)+4 {
+                length -= 4
+                dst[2] = uint8(length)
+                dst[1] = 0
+                dst[0] = 5<<2 | tagCopy1
+                return 3
+        }
+        if length < (1<<16)+(1<<8) {
+                length -= 1 << 8
+                dst[3] = uint8(length >> 8)
+                dst[2] = uint8(length >> 0)
+                dst[1] = 0
+                dst[0] = 6<<2 | tagCopy1
+                return 4
+        }
+        const maxRepeat = (1 << 24) - 1
+        length -= 1 << 16
+        left := 0
+        if length > maxRepeat {
+                left = length - maxRepeat + 4
+                length = maxRepeat - 4
+        }
+        dst[4] = uint8(length >> 16)
+        dst[3] = uint8(length >> 8)
+        dst[2] = uint8(length >> 0)
+        dst[1] = 0
+        dst[0] = 7<<2 | tagCopy1
+        if left > 0 {
+                return 5 + emitRepeat(dst[5:], offset, left)
+        }
+        return 5
+}
+
+// emitCopy writes a copy chunk and returns the number of bytes written.
+//
+// It assumes that:
+//
+//      dst is long enough to hold the encoded bytes
+//      1 <= offset && offset <= math.MaxUint32
+//      4 <= length && length <= 1 << 24
+func emitCopy(dst []byte, offset, length int) int {
+        if offset >= 65536 {
+                i := 0
+                if length > 64 {
+                        // Emit a length 64 copy, encoded as 5 bytes.
+                        dst[4] = uint8(offset >> 24)
+                        dst[3] = uint8(offset >> 16)
+                        dst[2] = uint8(offset >> 8)
+                        dst[1] = uint8(offset)
+                        dst[0] = 63<<2 | tagCopy4
+                        length -= 64
+                        if length >= 4 {
+                                // Emit remaining as repeats
+                                return 5 + emitRepeat(dst[5:], offset, length)
+                        }
+                        i = 5
+                }
+                if length == 0 {
+                        return i
+                }
+                // Emit a copy, offset encoded as 4 bytes.
+                dst[i+0] = uint8(length-1)<<2 | tagCopy4
+                dst[i+1] = uint8(offset)
+                dst[i+2] = uint8(offset >> 8)
+                dst[i+3] = uint8(offset >> 16)
+                dst[i+4] = uint8(offset >> 24)
+                return i + 5
+        }
+
+        // Offset no more than 2 bytes.
+        if length > 64 {
+                off := 3
+                if offset < 2048 {
+                        // emit 8 bytes as tagCopy1, rest as repeats.
+                        dst[1] = uint8(offset)
+                        dst[0] = uint8(offset>>8)<<5 | uint8(8-4)<<2 | tagCopy1
+                        length -= 8
+                        off = 2
+                } else {
+                        // Emit a length 60 copy, encoded as 3 bytes.
+                        // Emit remaining as repeat value (minimum 4 bytes).
+                        dst[2] = uint8(offset >> 8)
+                        dst[1] = uint8(offset)
+                        dst[0] = 59<<2 | tagCopy2
+                        length -= 60
+                }
+                // Emit remaining as repeats, at least 4 bytes remain.
+                return off + emitRepeat(dst[off:], offset, length)
+        }
+        if length >= 12 || offset >= 2048 {
+                // Emit the remaining copy, encoded as 3 bytes.
+                dst[2] = uint8(offset >> 8)
+                dst[1] = uint8(offset)
+                dst[0] = uint8(length-1)<<2 | tagCopy2
+                return 3
+        }
+        // Emit the remaining copy, encoded as 2 bytes.
+        dst[1] = uint8(offset)
+        dst[0] = uint8(offset>>8)<<5 | uint8(length-4)<<2 | tagCopy1
+        return 2
+}
+
+// emitCopyNoRepeat writes a copy chunk and returns the number of bytes written.
+//
+// It assumes that:
+//
+//      dst is long enough to hold the encoded bytes
+//      1 <= offset && offset <= math.MaxUint32
+//      4 <= length && length <= 1 << 24
+func emitCopyNoRepeat(dst []byte, offset, length int) int {
+        if offset >= 65536 {
+                i := 0
+                if length > 64 {
+                        // Emit a length 64 copy, encoded as 5 bytes.
+                        dst[4] = uint8(offset >> 24)
+                        dst[3] = uint8(offset >> 16)
+                        dst[2] = uint8(offset >> 8)
+                        dst[1] = uint8(offset)
+                        dst[0] = 63<<2 | tagCopy4
+                        length -= 64
+                        if length >= 4 {
+                                // Emit remaining as repeats
+                                return 5 + emitCopyNoRepeat(dst[5:], offset, length)
+                        }
+                        i = 5
+                }
+                if length == 0 {
+                        return i
+                }
+                // Emit a copy, offset encoded as 4 bytes.
+                dst[i+0] = uint8(length-1)<<2 | tagCopy4
+                dst[i+1] = uint8(offset)
+                dst[i+2] = uint8(offset >> 8)
+                dst[i+3] = uint8(offset >> 16)
+                dst[i+4] = uint8(offset >> 24)
+                return i + 5
+        }
+
+        // Offset no more than 2 bytes.
+        if length > 64 {
+                // Emit a length 60 copy, encoded as 3 bytes.
+                // Emit remaining as repeat value (minimum 4 bytes).
+                dst[2] = uint8(offset >> 8)
+                dst[1] = uint8(offset)
+                dst[0] = 59<<2 | tagCopy2
+                length -= 60
+                // Emit remaining as repeats, at least 4 bytes remain.
+                return 3 + emitCopyNoRepeat(dst[3:], offset, length)
+        }
+        if length >= 12 || offset >= 2048 {
+                // Emit the remaining copy, encoded as 3 bytes.
+                dst[2] = uint8(offset >> 8)
+                dst[1] = uint8(offset)
+                dst[0] = uint8(length-1)<<2 | tagCopy2
+                return 3
+        }
+        // Emit the remaining copy, encoded as 2 bytes.
+        dst[1] = uint8(offset)
+        dst[0] = uint8(offset>>8)<<5 | uint8(length-4)<<2 | tagCopy1
+        return 2
+}
+
+// matchLen returns how many bytes match in a and b
+//
+// It assumes that:
+//
+//      len(a) <= len(b)
+func matchLen(a []byte, b []byte) int {
+        b = b[:len(a)]
+        var checked int
+        if len(a) > 4 {
+                // Try 4 bytes first
+                if diff := load32(a, 0) ^ load32(b, 0); diff != 0 {
+                        return bits.TrailingZeros32(diff) >> 3
+                }
+                // Switch to 8 byte matching.
+                checked = 4
+                a = a[4:]
+                b = b[4:]
+                for len(a) >= 8 {
+                        b = b[:len(a)]
+                        if diff := load64(a, 0) ^ load64(b, 0); diff != 0 {
+                                return checked + (bits.TrailingZeros64(diff) >> 3)
+                        }
+                        checked += 8
+                        a = a[8:]
+                        b = b[8:]
+                }
+        }
+        b = b[:len(a)]
+        for i := range a {
+                if a[i] != b[i] {
+                        return int(i) + checked
+                }
+        }
+        return len(a) + checked
+}
+
+// input must be > inputMargin
+func calcBlockSize(src []byte) (d int) {
+        // Initialize the hash table.
+        const (
+                tableBits    = 13
+                maxTableSize = 1 << tableBits
+        )
+
+        var table [maxTableSize]uint32
+
+        // sLimit is when to stop looking for offset/length copies. The inputMargin
+        // lets us use a fast path for emitLiteral in the main loop, while we are
+        // looking for copies.
+        sLimit := len(src) - inputMargin
+
+        // Bail if we can't compress to at least this.
+        dstLimit := len(src) - len(src)>>5 - 5
+
+        // nextEmit is where in src the next emitLiteral should start from.
+        nextEmit := 0
+
+        // The encoded form must start with a literal, as there are no previous
+        // bytes to copy, so we start looking for hash matches at s == 1.
+        s := 1
+        cv := load64(src, s)
+
+        // We search for a repeat at -1, but don't output repeats when nextEmit == 0
+        repeat := 1
+
+        for {
+                candidate := 0
+                for {
+                        // Next src position to check
+                        nextS := s + (s-nextEmit)>>6 + 4
+                        if nextS > sLimit {
+                                goto emitRemainder
+                        }
+                        hash0 := hash6(cv, tableBits)
+                        hash1 := hash6(cv>>8, tableBits)
+                        candidate = int(table[hash0])
+                        candidate2 := int(table[hash1])
+                        table[hash0] = uint32(s)
+                        table[hash1] = uint32(s + 1)
+                        hash2 := hash6(cv>>16, tableBits)
+
+                        // Check repeat at offset checkRep.
+                        const checkRep = 1
+                        if uint32(cv>>(checkRep*8)) == load32(src, s-repeat+checkRep) {
+                                base := s + checkRep
+                                // Extend back
+                                for i := base - repeat; base > nextEmit && i > 0 && src[i-1] == src[base-1]; {
+                                        i--
+                                        base--
+                                }
+                                d += emitLiteralSize(src[nextEmit:base])
+
+                                // Extend forward
+                                candidate := s - repeat + 4 + checkRep
+                                s += 4 + checkRep
+                                for s <= sLimit {
+                                        if diff := load64(src, s) ^ load64(src, candidate); diff != 0 {
+                                                s += bits.TrailingZeros64(diff) >> 3
+                                                break
+                                        }
+                                        s += 8
+                                        candidate += 8
+                                }
+
+                                d += emitCopyNoRepeatSize(repeat, s-base)
+                                nextEmit = s
+                                if s >= sLimit {
+                                        goto emitRemainder
+                                }
+
+                                cv = load64(src, s)
+                                continue
+                        }
+
+                        if uint32(cv) == load32(src, candidate) {
+                                break
+                        }
+                        candidate = int(table[hash2])
+                        if uint32(cv>>8) == load32(src, candidate2) {
+                                table[hash2] = uint32(s + 2)
+                                candidate = candidate2
+                                s++
+                                break
+                        }
+                        table[hash2] = uint32(s + 2)
+                        if uint32(cv>>16) == load32(src, candidate) {
+                                s += 2
+                                break
+                        }
+
+                        cv = load64(src, nextS)
+                        s = nextS
+                }
+
+                // Extend backwards
+                for candidate > 0 && s > nextEmit && src[candidate-1] == src[s-1] {
+                        candidate--
+                        s--
+                }
+
+                // Bail if we exceed the maximum size.
+                if d+(s-nextEmit) > dstLimit {
+                        return 0
+                }
+
+                // A 4-byte match has been found. We'll later see if more than 4 bytes
+                // match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
+                // them as literal bytes.
+
+                d += emitLiteralSize(src[nextEmit:s])
+
+                // Call emitCopy, and then see if another emitCopy could be our next
+                // move. Repeat until we find no match for the input immediately after
+                // what was consumed by the last emitCopy call.
+                //
+                // If we exit this loop normally then we need to call emitLiteral next,
+                // though we don't yet know how big the literal will be. We handle that
+                // by proceeding to the next iteration of the main loop. We also can
+                // exit this loop via goto if we get close to exhausting the input.
+                for {
+                        // Invariant: we have a 4-byte match at s, and no need to emit any
+                        // literal bytes prior to s.
+                        base := s
+                        repeat = base - candidate
+
+                        // Extend the 4-byte match as long as possible.
+                        s += 4
+                        candidate += 4
+                        for s <= len(src)-8 {
+                                if diff := load64(src, s) ^ load64(src, candidate); diff != 0 {
+                                        s += bits.TrailingZeros64(diff) >> 3
+                                        break
+                                }
+                                s += 8
+                                candidate += 8
+                        }
+
+                        d += emitCopyNoRepeatSize(repeat, s-base)
+                        if false {
+                                // Validate match.
+                                a := src[base:s]
+                                b := src[base-repeat : base-repeat+(s-base)]
+                                if !bytes.Equal(a, b) {
+                                        panic("mismatch")
+                                }
+                        }
+
+                        nextEmit = s
+                        if s >= sLimit {
+                                goto emitRemainder
+                        }
+
+                        if d > dstLimit {
+                                // Do we have space for more, if not bail.
+                                return 0
+                        }
+                        // Check for an immediate match, otherwise start search at s+1
+                        x := load64(src, s-2)
+                        m2Hash := hash6(x, tableBits)
+                        currHash := hash6(x>>16, tableBits)
+                        candidate = int(table[currHash])
+                        table[m2Hash] = uint32(s - 2)
+                        table[currHash] = uint32(s)
+                        if uint32(x>>16) != load32(src, candidate) {
+                                cv = load64(src, s+1)
+                                s++
+                                break
+                        }
+                }
+        }
+
+emitRemainder:
+        if nextEmit < len(src) {
+                // Bail if we exceed the maximum size.
+                if d+len(src)-nextEmit > dstLimit {
+                        return 0
+                }
+                d += emitLiteralSize(src[nextEmit:])
+        }
+        return d
+}
+
+// length must be > inputMargin.
+func calcBlockSizeSmall(src []byte) (d int) {
+        // Initialize the hash table.
+        const (
+                tableBits    = 9
+                maxTableSize = 1 << tableBits
+        )
+
+        var table [maxTableSize]uint32
+
+        // sLimit is when to stop looking for offset/length copies. The inputMargin
+        // lets us use a fast path for emitLiteral in the main loop, while we are
+        // looking for copies.
+        sLimit := len(src) - inputMargin
+
+        // Bail if we can't compress to at least this.
+        dstLimit := len(src) - len(src)>>5 - 5
+
+        // nextEmit is where in src the next emitLiteral should start from.
+        nextEmit := 0
+
+        // The encoded form must start with a literal, as there are no previous
+        // bytes to copy, so we start looking for hash matches at s == 1.
+        s := 1
+        cv := load64(src, s)
+
+        // We search for a repeat at -1, but don't output repeats when nextEmit == 0
+        repeat := 1
+
+        for {
+                candidate := 0
+                for {
+                        // Next src position to check
+                        nextS := s + (s-nextEmit)>>6 + 4
+                        if nextS > sLimit {
+                                goto emitRemainder
+                        }
+                        hash0 := hash6(cv, tableBits)
+                        hash1 := hash6(cv>>8, tableBits)
+                        candidate = int(table[hash0])
+                        candidate2 := int(table[hash1])
+                        table[hash0] = uint32(s)
+                        table[hash1] = uint32(s + 1)
+                        hash2 := hash6(cv>>16, tableBits)
+
+                        // Check repeat at offset checkRep.
+                        const checkRep = 1
+                        if uint32(cv>>(checkRep*8)) == load32(src, s-repeat+checkRep) {
+                                base := s + checkRep
+                                // Extend back
+                                for i := base - repeat; base > nextEmit && i > 0 && src[i-1] == src[base-1]; {
+                                        i--
+                                        base--
+                                }
+                                d += emitLiteralSize(src[nextEmit:base])
+
+                                // Extend forward
+                                candidate := s - repeat + 4 + checkRep
+                                s += 4 + checkRep
+                                for s <= sLimit {
+                                        if diff := load64(src, s) ^ load64(src, candidate); diff != 0 {
+                                                s += bits.TrailingZeros64(diff) >> 3
+                                                break
+                                        }
+                                        s += 8
+                                        candidate += 8
+                                }
+
+                                d += emitCopyNoRepeatSize(repeat, s-base)
+                                nextEmit = s
+                                if s >= sLimit {
+                                        goto emitRemainder
+                                }
+
+                                cv = load64(src, s)
+                                continue
+                        }
+
+                        if uint32(cv) == load32(src, candidate) {
+                                break
+                        }
+                        candidate = int(table[hash2])
+                        if uint32(cv>>8) == load32(src, candidate2) {
+                                table[hash2] = uint32(s + 2)
+                                candidate = candidate2
+                                s++
+                                break
+                        }
+                        table[hash2] = uint32(s + 2)
+                        if uint32(cv>>16) == load32(src, candidate) {
+                                s += 2
+                                break
+                        }
+
+                        cv = load64(src, nextS)
+                        s = nextS
+                }
+
+                // Extend backwards
+                for candidate > 0 && s > nextEmit && src[candidate-1] == src[s-1] {
+                        candidate--
+                        s--
+                }
+
+                // Bail if we exceed the maximum size.
+                if d+(s-nextEmit) > dstLimit {
+                        return 0
+                }
+
+                // A 4-byte match has been found. We'll later see if more than 4 bytes
+                // match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
+                // them as literal bytes.
+
+                d += emitLiteralSize(src[nextEmit:s])
+
+                // Call emitCopy, and then see if another emitCopy could be our next
+                // move. Repeat until we find no match for the input immediately after
+                // what was consumed by the last emitCopy call.
+                //
+                // If we exit this loop normally then we need to call emitLiteral next,
+                // though we don't yet know how big the literal will be. We handle that
+                // by proceeding to the next iteration of the main loop. We also can
+                // exit this loop via goto if we get close to exhausting the input.
+                for {
+                        // Invariant: we have a 4-byte match at s, and no need to emit any
+                        // literal bytes prior to s.
+                        base := s
+                        repeat = base - candidate
+
+                        // Extend the 4-byte match as long as possible.
+                        s += 4
+                        candidate += 4
+                        for s <= len(src)-8 {
+                                if diff := load64(src, s) ^ load64(src, candidate); diff != 0 {
+                                        s += bits.TrailingZeros64(diff) >> 3
+                                        break
+                                }
+                                s += 8
+                                candidate += 8
+                        }
+
+                        d += emitCopyNoRepeatSize(repeat, s-base)
+                        if false {
+                                // Validate match.
+                                a := src[base:s]
+                                b := src[base-repeat : base-repeat+(s-base)]
+                                if !bytes.Equal(a, b) {
+                                        panic("mismatch")
+                                }
+                        }
+
+                        nextEmit = s
+                        if s >= sLimit {
+                                goto emitRemainder
+                        }
+
+                        if d > dstLimit {
+                                // Do we have space for more, if not bail.
+                                return 0
+                        }
+                        // Check for an immediate match, otherwise start search at s+1
+                        x := load64(src, s-2)
+                        m2Hash := hash6(x, tableBits)
+                        currHash := hash6(x>>16, tableBits)
+                        candidate = int(table[currHash])
+                        table[m2Hash] = uint32(s - 2)
+                        table[currHash] = uint32(s)
+                        if uint32(x>>16) != load32(src, candidate) {
+                                cv = load64(src, s+1)
+                                s++
+                                break
+                        }
+                }
+        }
+
+emitRemainder:
+        if nextEmit < len(src) {
+                // Bail if we exceed the maximum size.
+                if d+len(src)-nextEmit > dstLimit {
+                        return 0
+                }
+                d += emitLiteralSize(src[nextEmit:])
+        }
+        return d
+}
+
+// emitLiteral writes a literal chunk and returns the number of bytes written.
+//
+// It assumes that:
+//
+//      dst is long enough to hold the encoded bytes
+//      0 <= len(lit) && len(lit) <= math.MaxUint32
+func emitLiteralSize(lit []byte) int {
+        if len(lit) == 0 {
+                return 0
+        }
+        switch {
+        case len(lit) <= 60:
+                return len(lit) + 1
+        case len(lit) <= 1<<8:
+                return len(lit) + 2
+        case len(lit) <= 1<<16:
+                return len(lit) + 3
+        case len(lit) <= 1<<24:
+                return len(lit) + 4
+        default:
+                return len(lit) + 5
+        }
+}
+
+func cvtLZ4BlockAsm(dst []byte, src []byte) (uncompressed int, dstUsed int) {
+        panic("cvtLZ4BlockAsm should be unreachable")
+}
+
+func cvtLZ4BlockSnappyAsm(dst []byte, src []byte) (uncompressed int, dstUsed int) {
+        panic("cvtLZ4BlockSnappyAsm should be unreachable")
+}
+
+func cvtLZ4sBlockAsm(dst []byte, src []byte) (uncompressed int, dstUsed int) {
+        panic("cvtLZ4sBlockAsm should be unreachable")
+}
+
+func cvtLZ4sBlockSnappyAsm(dst []byte, src []byte) (uncompressed int, dstUsed int) {
+        panic("cvtLZ4sBlockSnappyAsm should be unreachable")
+}
diff --git a/vendor/github.com/klauspost/compress/s2/encodeblock_amd64.go b/vendor/github.com/klauspost/compress/s2/encodeblock_amd64.go
new file mode 100644
index 0000000..297e415
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/encodeblock_amd64.go
@@ -0,0 +1,228 @@
+// Code generated by command: go run gen.go -out ../encodeblock_amd64.s -stubs ../encodeblock_amd64.go -pkg=s2. DO NOT EDIT.
+
+//go:build !appengine && !noasm && gc && !noasm
+
+package s2
+
+func _dummy_()
+
+// encodeBlockAsm encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 4294967295 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeBlockAsm(dst []byte, src []byte) int
+
+// encodeBlockAsm4MB encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 4194304 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeBlockAsm4MB(dst []byte, src []byte) int
+
+// encodeBlockAsm12B encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 16383 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeBlockAsm12B(dst []byte, src []byte) int
+
+// encodeBlockAsm10B encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 4095 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeBlockAsm10B(dst []byte, src []byte) int
+
+// encodeBlockAsm8B encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 511 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeBlockAsm8B(dst []byte, src []byte) int
+
+// encodeBetterBlockAsm encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 4294967295 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeBetterBlockAsm(dst []byte, src []byte) int
+
+// encodeBetterBlockAsm4MB encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 4194304 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeBetterBlockAsm4MB(dst []byte, src []byte) int
+
+// encodeBetterBlockAsm12B encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 16383 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeBetterBlockAsm12B(dst []byte, src []byte) int
+
+// encodeBetterBlockAsm10B encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 4095 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeBetterBlockAsm10B(dst []byte, src []byte) int
+
+// encodeBetterBlockAsm8B encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 511 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeBetterBlockAsm8B(dst []byte, src []byte) int
+
+// encodeSnappyBlockAsm encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 4294967295 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeSnappyBlockAsm(dst []byte, src []byte) int
+
+// encodeSnappyBlockAsm64K encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 65535 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeSnappyBlockAsm64K(dst []byte, src []byte) int
+
+// encodeSnappyBlockAsm12B encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 16383 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeSnappyBlockAsm12B(dst []byte, src []byte) int
+
+// encodeSnappyBlockAsm10B encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 4095 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeSnappyBlockAsm10B(dst []byte, src []byte) int
+
+// encodeSnappyBlockAsm8B encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 511 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeSnappyBlockAsm8B(dst []byte, src []byte) int
+
+// encodeSnappyBetterBlockAsm encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 4294967295 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeSnappyBetterBlockAsm(dst []byte, src []byte) int
+
+// encodeSnappyBetterBlockAsm64K encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 65535 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeSnappyBetterBlockAsm64K(dst []byte, src []byte) int
+
+// encodeSnappyBetterBlockAsm12B encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 16383 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeSnappyBetterBlockAsm12B(dst []byte, src []byte) int
+
+// encodeSnappyBetterBlockAsm10B encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 4095 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeSnappyBetterBlockAsm10B(dst []byte, src []byte) int
+
+// encodeSnappyBetterBlockAsm8B encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 511 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func encodeSnappyBetterBlockAsm8B(dst []byte, src []byte) int
+
+// calcBlockSize encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 4294967295 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func calcBlockSize(src []byte) int
+
+// calcBlockSizeSmall encodes a non-empty src to a guaranteed-large-enough dst.
+// Maximum input 1024 bytes.
+// It assumes that the varint-encoded length of the decompressed bytes has already been written.
+//
+//go:noescape
+func calcBlockSizeSmall(src []byte) int
+
+// emitLiteral writes a literal chunk and returns the number of bytes written.
+//
+// It assumes that:
+//
+//      dst is long enough to hold the encoded bytes with margin of 0 bytes
+//      0 <= len(lit) && len(lit) <= math.MaxUint32
+//
+//go:noescape
+func emitLiteral(dst []byte, lit []byte) int
+
+// emitRepeat writes a repeat chunk and returns the number of bytes written.
+// Length must be at least 4 and < 1<<32
+//
+//go:noescape
+func emitRepeat(dst []byte, offset int, length int) int
+
+// emitCopy writes a copy chunk and returns the number of bytes written.
+//
+// It assumes that:
+//
+//      dst is long enough to hold the encoded bytes
+//      1 <= offset && offset <= math.MaxUint32
+//      4 <= length && length <= 1 << 24
+//
+//go:noescape
+func emitCopy(dst []byte, offset int, length int) int
+
+// emitCopyNoRepeat writes a copy chunk and returns the number of bytes written.
+//
+// It assumes that:
+//
+//      dst is long enough to hold the encoded bytes
+//      1 <= offset && offset <= math.MaxUint32
+//      4 <= length && length <= 1 << 24
+//
+//go:noescape
+func emitCopyNoRepeat(dst []byte, offset int, length int) int
+
+// matchLen returns how many bytes match in a and b
+//
+// It assumes that:
+//
+//      len(a) <= len(b)
+//
+//go:noescape
+func matchLen(a []byte, b []byte) int
+
+// cvtLZ4Block converts an LZ4 block to S2
+//
+//go:noescape
+func cvtLZ4BlockAsm(dst []byte, src []byte) (uncompressed int, dstUsed int)
+
+// cvtLZ4sBlock converts an LZ4s block to S2
+//
+//go:noescape
+func cvtLZ4sBlockAsm(dst []byte, src []byte) (uncompressed int, dstUsed int)
+
+// cvtLZ4Block converts an LZ4 block to Snappy
+//
+//go:noescape
+func cvtLZ4BlockSnappyAsm(dst []byte, src []byte) (uncompressed int, dstUsed int)
+
+// cvtLZ4sBlock converts an LZ4s block to Snappy
+//
+//go:noescape
+func cvtLZ4sBlockSnappyAsm(dst []byte, src []byte) (uncompressed int, dstUsed int)
diff --git a/vendor/github.com/klauspost/compress/s2/encodeblock_amd64.s b/vendor/github.com/klauspost/compress/s2/encodeblock_amd64.s
new file mode 100644
index 0000000..5f110d1
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/encodeblock_amd64.s
@@ -0,0 +1,21169 @@
+// Code generated by command: go run gen.go -out ../encodeblock_amd64.s -stubs ../encodeblock_amd64.go -pkg=s2. DO NOT EDIT.
+
+//go:build !appengine && !noasm && gc && !noasm
+
+#include "textflag.h"
+
+// func _dummy_()
+TEXT ·_dummy_(SB), $0
+#ifdef GOAMD64_v4
+#ifndef GOAMD64_v3
+#define GOAMD64_v3
+#endif
+#endif
+        RET
+
+// func encodeBlockAsm(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeBlockAsm(SB), $65560-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000200, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeBlockAsm:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeBlockAsm
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  CX, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeBlockAsm:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x06, BX
+        LEAL  4(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeBlockAsm
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHRQ  $0x08, R10
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x32, R9
+        SHLQ  $0x10, R10
+        IMULQ R8, R10
+        SHRQ  $0x32, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  24(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        LEAL  1(CX), R9
+        MOVL  R9, 24(SP)(R10*4)
+        MOVQ  SI, R9
+        SHRQ  $0x10, R9
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x32, R9
+        MOVL  CX, R8
+        SUBL  16(SP), R8
+        MOVL  1(DX)(R8*1), R10
+        MOVQ  SI, R8
+        SHRQ  $0x08, R8
+        CMPL  R8, R10
+        JNE   no_repeat_found_encodeBlockAsm
+        LEAL  1(CX), SI
+        MOVL  12(SP), DI
+        MOVL  SI, BX
+        SUBL  16(SP), BX
+        JZ    repeat_extend_back_end_encodeBlockAsm
+
+repeat_extend_back_loop_encodeBlockAsm:
+        CMPL SI, DI
+        JBE  repeat_extend_back_end_encodeBlockAsm
+        MOVB -1(DX)(BX*1), R8
+        MOVB -1(DX)(SI*1), R9
+        CMPB R8, R9
+        JNE  repeat_extend_back_end_encodeBlockAsm
+        LEAL -1(SI), SI
+        DECL BX
+        JNZ  repeat_extend_back_loop_encodeBlockAsm
+
+repeat_extend_back_end_encodeBlockAsm:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_repeat_emit_encodeBlockAsm
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_repeat_emit_encodeBlockAsm
+        CMPL BX, $0x00000100
+        JB   two_bytes_repeat_emit_encodeBlockAsm
+        CMPL BX, $0x00010000
+        JB   three_bytes_repeat_emit_encodeBlockAsm
+        CMPL BX, $0x01000000
+        JB   four_bytes_repeat_emit_encodeBlockAsm
+        MOVB $0xfc, (AX)
+        MOVL BX, 1(AX)
+        ADDQ $0x05, AX
+        JMP  memmove_long_repeat_emit_encodeBlockAsm
+
+four_bytes_repeat_emit_encodeBlockAsm:
+        MOVL BX, R10
+        SHRL $0x10, R10
+        MOVB $0xf8, (AX)
+        MOVW BX, 1(AX)
+        MOVB R10, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_repeat_emit_encodeBlockAsm
+
+three_bytes_repeat_emit_encodeBlockAsm:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_repeat_emit_encodeBlockAsm
+
+two_bytes_repeat_emit_encodeBlockAsm:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_repeat_emit_encodeBlockAsm
+        JMP  memmove_long_repeat_emit_encodeBlockAsm
+
+one_byte_repeat_emit_encodeBlockAsm:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_repeat_emit_encodeBlockAsm:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm_memmove_move_17through32
+        JMP  emit_lit_memmove_repeat_emit_encodeBlockAsm_memmove_move_33through64
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm_memmove_move_8:
+        MOVQ (R9), R10
+        MOVQ R10, (AX)
+        JMP  memmove_end_copy_repeat_emit_encodeBlockAsm
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_repeat_emit_encodeBlockAsm
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_repeat_emit_encodeBlockAsm
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_repeat_emit_encodeBlockAsm:
+        MOVQ BX, AX
+        JMP  emit_literal_done_repeat_emit_encodeBlockAsm
+
+memmove_long_repeat_emit_encodeBlockAsm:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R11
+        SHRQ  $0x05, R11
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R12
+        SUBQ  R10, R12
+        DECQ  R11
+        JA    emit_lit_memmove_long_repeat_emit_encodeBlockAsmlarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R12*1), R10
+        LEAQ  -32(AX)(R12*1), R13
+
+emit_lit_memmove_long_repeat_emit_encodeBlockAsmlarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R13)
+        MOVOA X5, 16(R13)
+        ADDQ  $0x20, R13
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R12
+        DECQ  R11
+        JNA   emit_lit_memmove_long_repeat_emit_encodeBlockAsmlarge_big_loop_back
+
+emit_lit_memmove_long_repeat_emit_encodeBlockAsmlarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R12*1), X4
+        MOVOU -16(R9)(R12*1), X5
+        MOVOA X4, -32(AX)(R12*1)
+        MOVOA X5, -16(AX)(R12*1)
+        ADDQ  $0x20, R12
+        CMPQ  R8, R12
+        JAE   emit_lit_memmove_long_repeat_emit_encodeBlockAsmlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_repeat_emit_encodeBlockAsm:
+        ADDL $0x05, CX
+        MOVL CX, BX
+        SUBL 16(SP), BX
+        MOVQ src_len+32(FP), R8
+        SUBL CX, R8
+        LEAQ (DX)(CX*1), R9
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_repeat_extend_encodeBlockAsm:
+        CMPL R8, $0x10
+        JB   matchlen_match8_repeat_extend_encodeBlockAsm
+        MOVQ (R9)(R11*1), R10
+        MOVQ 8(R9)(R11*1), R12
+        XORQ (BX)(R11*1), R10
+        JNZ  matchlen_bsf_8_repeat_extend_encodeBlockAsm
+        XORQ 8(BX)(R11*1), R12
+        JNZ  matchlen_bsf_16repeat_extend_encodeBlockAsm
+        LEAL -16(R8), R8
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_repeat_extend_encodeBlockAsm
+
+matchlen_bsf_16repeat_extend_encodeBlockAsm:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  repeat_extend_forward_end_encodeBlockAsm
+
+matchlen_match8_repeat_extend_encodeBlockAsm:
+        CMPL R8, $0x08
+        JB   matchlen_match4_repeat_extend_encodeBlockAsm
+        MOVQ (R9)(R11*1), R10
+        XORQ (BX)(R11*1), R10
+        JNZ  matchlen_bsf_8_repeat_extend_encodeBlockAsm
+        LEAL -8(R8), R8
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_repeat_extend_encodeBlockAsm
+
+matchlen_bsf_8_repeat_extend_encodeBlockAsm:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  repeat_extend_forward_end_encodeBlockAsm
+
+matchlen_match4_repeat_extend_encodeBlockAsm:
+        CMPL R8, $0x04
+        JB   matchlen_match2_repeat_extend_encodeBlockAsm
+        MOVL (R9)(R11*1), R10
+        CMPL (BX)(R11*1), R10
+        JNE  matchlen_match2_repeat_extend_encodeBlockAsm
+        LEAL -4(R8), R8
+        LEAL 4(R11), R11
+
+matchlen_match2_repeat_extend_encodeBlockAsm:
+        CMPL R8, $0x01
+        JE   matchlen_match1_repeat_extend_encodeBlockAsm
+        JB   repeat_extend_forward_end_encodeBlockAsm
+        MOVW (R9)(R11*1), R10
+        CMPW (BX)(R11*1), R10
+        JNE  matchlen_match1_repeat_extend_encodeBlockAsm
+        LEAL 2(R11), R11
+        SUBL $0x02, R8
+        JZ   repeat_extend_forward_end_encodeBlockAsm
+
+matchlen_match1_repeat_extend_encodeBlockAsm:
+        MOVB (R9)(R11*1), R10
+        CMPB (BX)(R11*1), R10
+        JNE  repeat_extend_forward_end_encodeBlockAsm
+        LEAL 1(R11), R11
+
+repeat_extend_forward_end_encodeBlockAsm:
+        ADDL  R11, CX
+        MOVL  CX, BX
+        SUBL  SI, BX
+        MOVL  16(SP), SI
+        TESTL DI, DI
+        JZ    repeat_as_copy_encodeBlockAsm
+
+        // emitRepeat
+emit_repeat_again_match_repeat_encodeBlockAsm:
+        MOVL BX, DI
+        LEAL -4(BX), BX
+        CMPL DI, $0x08
+        JBE  repeat_two_match_repeat_encodeBlockAsm
+        CMPL DI, $0x0c
+        JAE  cant_repeat_two_offset_match_repeat_encodeBlockAsm
+        CMPL SI, $0x00000800
+        JB   repeat_two_offset_match_repeat_encodeBlockAsm
+
+cant_repeat_two_offset_match_repeat_encodeBlockAsm:
+        CMPL BX, $0x00000104
+        JB   repeat_three_match_repeat_encodeBlockAsm
+        CMPL BX, $0x00010100
+        JB   repeat_four_match_repeat_encodeBlockAsm
+        CMPL BX, $0x0100ffff
+        JB   repeat_five_match_repeat_encodeBlockAsm
+        LEAL -16842747(BX), BX
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_match_repeat_encodeBlockAsm
+
+repeat_five_match_repeat_encodeBlockAsm:
+        LEAL -65536(BX), BX
+        MOVL BX, SI
+        MOVW $0x001d, (AX)
+        MOVW BX, 2(AX)
+        SARL $0x10, SI
+        MOVB SI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_four_match_repeat_encodeBlockAsm:
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_three_match_repeat_encodeBlockAsm:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_two_match_repeat_encodeBlockAsm:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_two_offset_match_repeat_encodeBlockAsm:
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_as_copy_encodeBlockAsm:
+        // emitCopy
+        CMPL SI, $0x00010000
+        JB   two_byte_offset_repeat_as_copy_encodeBlockAsm
+        CMPL BX, $0x40
+        JBE  four_bytes_remain_repeat_as_copy_encodeBlockAsm
+        MOVB $0xff, (AX)
+        MOVL SI, 1(AX)
+        LEAL -64(BX), BX
+        ADDQ $0x05, AX
+        CMPL BX, $0x04
+        JB   four_bytes_remain_repeat_as_copy_encodeBlockAsm
+
+        // emitRepeat
+emit_repeat_again_repeat_as_copy_encodeBlockAsm_emit_copy:
+        MOVL BX, DI
+        LEAL -4(BX), BX
+        CMPL DI, $0x08
+        JBE  repeat_two_repeat_as_copy_encodeBlockAsm_emit_copy
+        CMPL DI, $0x0c
+        JAE  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm_emit_copy
+        CMPL SI, $0x00000800
+        JB   repeat_two_offset_repeat_as_copy_encodeBlockAsm_emit_copy
+
+cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm_emit_copy:
+        CMPL BX, $0x00000104
+        JB   repeat_three_repeat_as_copy_encodeBlockAsm_emit_copy
+        CMPL BX, $0x00010100
+        JB   repeat_four_repeat_as_copy_encodeBlockAsm_emit_copy
+        CMPL BX, $0x0100ffff
+        JB   repeat_five_repeat_as_copy_encodeBlockAsm_emit_copy
+        LEAL -16842747(BX), BX
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_repeat_as_copy_encodeBlockAsm_emit_copy
+
+repeat_five_repeat_as_copy_encodeBlockAsm_emit_copy:
+        LEAL -65536(BX), BX
+        MOVL BX, SI
+        MOVW $0x001d, (AX)
+        MOVW BX, 2(AX)
+        SARL $0x10, SI
+        MOVB SI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_four_repeat_as_copy_encodeBlockAsm_emit_copy:
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_three_repeat_as_copy_encodeBlockAsm_emit_copy:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_two_repeat_as_copy_encodeBlockAsm_emit_copy:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_two_offset_repeat_as_copy_encodeBlockAsm_emit_copy:
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+four_bytes_remain_repeat_as_copy_encodeBlockAsm:
+        TESTL BX, BX
+        JZ    repeat_end_emit_encodeBlockAsm
+        XORL  DI, DI
+        LEAL  -1(DI)(BX*4), BX
+        MOVB  BL, (AX)
+        MOVL  SI, 1(AX)
+        ADDQ  $0x05, AX
+        JMP   repeat_end_emit_encodeBlockAsm
+
+two_byte_offset_repeat_as_copy_encodeBlockAsm:
+        CMPL BX, $0x40
+        JBE  two_byte_offset_short_repeat_as_copy_encodeBlockAsm
+        CMPL SI, $0x00000800
+        JAE  long_offset_short_repeat_as_copy_encodeBlockAsm
+        MOVL $0x00000001, DI
+        LEAL 16(DI), DI
+        MOVB SI, 1(AX)
+        MOVL SI, R8
+        SHRL $0x08, R8
+        SHLL $0x05, R8
+        ORL  R8, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, BX
+
+        // emitRepeat
+        LEAL -4(BX), BX
+        JMP  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b
+
+emit_repeat_again_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b:
+        MOVL BX, DI
+        LEAL -4(BX), BX
+        CMPL DI, $0x08
+        JBE  repeat_two_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b
+        CMPL DI, $0x0c
+        JAE  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b
+        CMPL SI, $0x00000800
+        JB   repeat_two_offset_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b
+
+cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b:
+        CMPL BX, $0x00000104
+        JB   repeat_three_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b
+        CMPL BX, $0x00010100
+        JB   repeat_four_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b
+        CMPL BX, $0x0100ffff
+        JB   repeat_five_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b
+        LEAL -16842747(BX), BX
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b
+
+repeat_five_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b:
+        LEAL -65536(BX), BX
+        MOVL BX, SI
+        MOVW $0x001d, (AX)
+        MOVW BX, 2(AX)
+        SARL $0x10, SI
+        MOVB SI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_four_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b:
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_three_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_two_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_two_offset_repeat_as_copy_encodeBlockAsm_emit_copy_short_2b:
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+long_offset_short_repeat_as_copy_encodeBlockAsm:
+        MOVB $0xee, (AX)
+        MOVW SI, 1(AX)
+        LEAL -60(BX), BX
+        ADDQ $0x03, AX
+
+        // emitRepeat
+emit_repeat_again_repeat_as_copy_encodeBlockAsm_emit_copy_short:
+        MOVL BX, DI
+        LEAL -4(BX), BX
+        CMPL DI, $0x08
+        JBE  repeat_two_repeat_as_copy_encodeBlockAsm_emit_copy_short
+        CMPL DI, $0x0c
+        JAE  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm_emit_copy_short
+        CMPL SI, $0x00000800
+        JB   repeat_two_offset_repeat_as_copy_encodeBlockAsm_emit_copy_short
+
+cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm_emit_copy_short:
+        CMPL BX, $0x00000104
+        JB   repeat_three_repeat_as_copy_encodeBlockAsm_emit_copy_short
+        CMPL BX, $0x00010100
+        JB   repeat_four_repeat_as_copy_encodeBlockAsm_emit_copy_short
+        CMPL BX, $0x0100ffff
+        JB   repeat_five_repeat_as_copy_encodeBlockAsm_emit_copy_short
+        LEAL -16842747(BX), BX
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_repeat_as_copy_encodeBlockAsm_emit_copy_short
+
+repeat_five_repeat_as_copy_encodeBlockAsm_emit_copy_short:
+        LEAL -65536(BX), BX
+        MOVL BX, SI
+        MOVW $0x001d, (AX)
+        MOVW BX, 2(AX)
+        SARL $0x10, SI
+        MOVB SI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_four_repeat_as_copy_encodeBlockAsm_emit_copy_short:
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_three_repeat_as_copy_encodeBlockAsm_emit_copy_short:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_two_repeat_as_copy_encodeBlockAsm_emit_copy_short:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+repeat_two_offset_repeat_as_copy_encodeBlockAsm_emit_copy_short:
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+two_byte_offset_short_repeat_as_copy_encodeBlockAsm:
+        MOVL BX, DI
+        SHLL $0x02, DI
+        CMPL BX, $0x0c
+        JAE  emit_copy_three_repeat_as_copy_encodeBlockAsm
+        CMPL SI, $0x00000800
+        JAE  emit_copy_three_repeat_as_copy_encodeBlockAsm
+        LEAL -15(DI), DI
+        MOVB SI, 1(AX)
+        SHRL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm
+
+emit_copy_three_repeat_as_copy_encodeBlockAsm:
+        LEAL -2(DI), DI
+        MOVB DI, (AX)
+        MOVW SI, 1(AX)
+        ADDQ $0x03, AX
+
+repeat_end_emit_encodeBlockAsm:
+        MOVL CX, 12(SP)
+        JMP  search_loop_encodeBlockAsm
+
+no_repeat_found_encodeBlockAsm:
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate_match_encodeBlockAsm
+        SHRQ $0x08, SI
+        MOVL 24(SP)(R9*4), BX
+        LEAL 2(CX), R8
+        CMPL (DX)(DI*1), SI
+        JEQ  candidate2_match_encodeBlockAsm
+        MOVL R8, 24(SP)(R9*4)
+        SHRQ $0x08, SI
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate3_match_encodeBlockAsm
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeBlockAsm
+
+candidate3_match_encodeBlockAsm:
+        ADDL $0x02, CX
+        JMP  candidate_match_encodeBlockAsm
+
+candidate2_match_encodeBlockAsm:
+        MOVL R8, 24(SP)(R9*4)
+        INCL CX
+        MOVL DI, BX
+
+candidate_match_encodeBlockAsm:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeBlockAsm
+
+match_extend_back_loop_encodeBlockAsm:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeBlockAsm
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeBlockAsm
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeBlockAsm
+        JMP  match_extend_back_loop_encodeBlockAsm
+
+match_extend_back_end_encodeBlockAsm:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 5(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeBlockAsm
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeBlockAsm:
+        MOVL CX, SI
+        MOVL 12(SP), DI
+        CMPL DI, SI
+        JEQ  emit_literal_done_match_emit_encodeBlockAsm
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(DI*1), SI
+        SUBL DI, R8
+        LEAL -1(R8), DI
+        CMPL DI, $0x3c
+        JB   one_byte_match_emit_encodeBlockAsm
+        CMPL DI, $0x00000100
+        JB   two_bytes_match_emit_encodeBlockAsm
+        CMPL DI, $0x00010000
+        JB   three_bytes_match_emit_encodeBlockAsm
+        CMPL DI, $0x01000000
+        JB   four_bytes_match_emit_encodeBlockAsm
+        MOVB $0xfc, (AX)
+        MOVL DI, 1(AX)
+        ADDQ $0x05, AX
+        JMP  memmove_long_match_emit_encodeBlockAsm
+
+four_bytes_match_emit_encodeBlockAsm:
+        MOVL DI, R9
+        SHRL $0x10, R9
+        MOVB $0xf8, (AX)
+        MOVW DI, 1(AX)
+        MOVB R9, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_match_emit_encodeBlockAsm
+
+three_bytes_match_emit_encodeBlockAsm:
+        MOVB $0xf4, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeBlockAsm
+
+two_bytes_match_emit_encodeBlockAsm:
+        MOVB $0xf0, (AX)
+        MOVB DI, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DI, $0x40
+        JB   memmove_match_emit_encodeBlockAsm
+        JMP  memmove_long_match_emit_encodeBlockAsm
+
+one_byte_match_emit_encodeBlockAsm:
+        SHLB $0x02, DI
+        MOVB DI, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeBlockAsm:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeBlockAsm_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeBlockAsm_memmove_move_8:
+        MOVQ (SI), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_match_emit_encodeBlockAsm
+
+emit_lit_memmove_match_emit_encodeBlockAsm_memmove_move_8through16:
+        MOVQ (SI), R9
+        MOVQ -8(SI)(R8*1), SI
+        MOVQ R9, (AX)
+        MOVQ SI, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBlockAsm
+
+emit_lit_memmove_match_emit_encodeBlockAsm_memmove_move_17through32:
+        MOVOU (SI), X0
+        MOVOU -16(SI)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeBlockAsm
+
+emit_lit_memmove_match_emit_encodeBlockAsm_memmove_move_33through64:
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeBlockAsm:
+        MOVQ DI, AX
+        JMP  emit_literal_done_match_emit_encodeBlockAsm
+
+memmove_long_match_emit_encodeBlockAsm:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveLong
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVQ  R8, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_match_emit_encodeBlockAsmlarge_forward_sse_loop_32
+        LEAQ  -32(SI)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_match_emit_encodeBlockAsmlarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_match_emit_encodeBlockAsmlarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeBlockAsmlarge_forward_sse_loop_32:
+        MOVOU -32(SI)(R11*1), X4
+        MOVOU -16(SI)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  R8, R11
+        JAE   emit_lit_memmove_long_match_emit_encodeBlockAsmlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  DI, AX
+
+emit_literal_done_match_emit_encodeBlockAsm:
+match_nolit_loop_encodeBlockAsm:
+        MOVL CX, SI
+        SUBL BX, SI
+        MOVL SI, 16(SP)
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), SI
+        SUBL CX, SI
+        LEAQ (DX)(CX*1), DI
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R9, R9
+
+matchlen_loopback_16_match_nolit_encodeBlockAsm:
+        CMPL SI, $0x10
+        JB   matchlen_match8_match_nolit_encodeBlockAsm
+        MOVQ (DI)(R9*1), R8
+        MOVQ 8(DI)(R9*1), R10
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeBlockAsm
+        XORQ 8(BX)(R9*1), R10
+        JNZ  matchlen_bsf_16match_nolit_encodeBlockAsm
+        LEAL -16(SI), SI
+        LEAL 16(R9), R9
+        JMP  matchlen_loopback_16_match_nolit_encodeBlockAsm
+
+matchlen_bsf_16match_nolit_encodeBlockAsm:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL 8(R9)(R10*1), R9
+        JMP  match_nolit_end_encodeBlockAsm
+
+matchlen_match8_match_nolit_encodeBlockAsm:
+        CMPL SI, $0x08
+        JB   matchlen_match4_match_nolit_encodeBlockAsm
+        MOVQ (DI)(R9*1), R8
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeBlockAsm
+        LEAL -8(SI), SI
+        LEAL 8(R9), R9
+        JMP  matchlen_match4_match_nolit_encodeBlockAsm
+
+matchlen_bsf_8_match_nolit_encodeBlockAsm:
+#ifdef GOAMD64_v3
+        TZCNTQ R8, R8
+
+#else
+        BSFQ R8, R8
+
+#endif
+        SARQ $0x03, R8
+        LEAL (R9)(R8*1), R9
+        JMP  match_nolit_end_encodeBlockAsm
+
+matchlen_match4_match_nolit_encodeBlockAsm:
+        CMPL SI, $0x04
+        JB   matchlen_match2_match_nolit_encodeBlockAsm
+        MOVL (DI)(R9*1), R8
+        CMPL (BX)(R9*1), R8
+        JNE  matchlen_match2_match_nolit_encodeBlockAsm
+        LEAL -4(SI), SI
+        LEAL 4(R9), R9
+
+matchlen_match2_match_nolit_encodeBlockAsm:
+        CMPL SI, $0x01
+        JE   matchlen_match1_match_nolit_encodeBlockAsm
+        JB   match_nolit_end_encodeBlockAsm
+        MOVW (DI)(R9*1), R8
+        CMPW (BX)(R9*1), R8
+        JNE  matchlen_match1_match_nolit_encodeBlockAsm
+        LEAL 2(R9), R9
+        SUBL $0x02, SI
+        JZ   match_nolit_end_encodeBlockAsm
+
+matchlen_match1_match_nolit_encodeBlockAsm:
+        MOVB (DI)(R9*1), R8
+        CMPB (BX)(R9*1), R8
+        JNE  match_nolit_end_encodeBlockAsm
+        LEAL 1(R9), R9
+
+match_nolit_end_encodeBlockAsm:
+        ADDL R9, CX
+        MOVL 16(SP), BX
+        ADDL $0x04, R9
+        MOVL CX, 12(SP)
+
+        // emitCopy
+        CMPL BX, $0x00010000
+        JB   two_byte_offset_match_nolit_encodeBlockAsm
+        CMPL R9, $0x40
+        JBE  four_bytes_remain_match_nolit_encodeBlockAsm
+        MOVB $0xff, (AX)
+        MOVL BX, 1(AX)
+        LEAL -64(R9), R9
+        ADDQ $0x05, AX
+        CMPL R9, $0x04
+        JB   four_bytes_remain_match_nolit_encodeBlockAsm
+
+        // emitRepeat
+emit_repeat_again_match_nolit_encodeBlockAsm_emit_copy:
+        MOVL R9, SI
+        LEAL -4(R9), R9
+        CMPL SI, $0x08
+        JBE  repeat_two_match_nolit_encodeBlockAsm_emit_copy
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBlockAsm_emit_copy
+        CMPL BX, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBlockAsm_emit_copy
+
+cant_repeat_two_offset_match_nolit_encodeBlockAsm_emit_copy:
+        CMPL R9, $0x00000104
+        JB   repeat_three_match_nolit_encodeBlockAsm_emit_copy
+        CMPL R9, $0x00010100
+        JB   repeat_four_match_nolit_encodeBlockAsm_emit_copy
+        CMPL R9, $0x0100ffff
+        JB   repeat_five_match_nolit_encodeBlockAsm_emit_copy
+        LEAL -16842747(R9), R9
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_match_nolit_encodeBlockAsm_emit_copy
+
+repeat_five_match_nolit_encodeBlockAsm_emit_copy:
+        LEAL -65536(R9), R9
+        MOVL R9, BX
+        MOVW $0x001d, (AX)
+        MOVW R9, 2(AX)
+        SARL $0x10, BX
+        MOVB BL, 4(AX)
+        ADDQ $0x05, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+repeat_four_match_nolit_encodeBlockAsm_emit_copy:
+        LEAL -256(R9), R9
+        MOVW $0x0019, (AX)
+        MOVW R9, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+repeat_three_match_nolit_encodeBlockAsm_emit_copy:
+        LEAL -4(R9), R9
+        MOVW $0x0015, (AX)
+        MOVB R9, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+repeat_two_match_nolit_encodeBlockAsm_emit_copy:
+        SHLL $0x02, R9
+        ORL  $0x01, R9
+        MOVW R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+repeat_two_offset_match_nolit_encodeBlockAsm_emit_copy:
+        XORQ SI, SI
+        LEAL 1(SI)(R9*4), R9
+        MOVB BL, 1(AX)
+        SARL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, R9
+        MOVB R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+four_bytes_remain_match_nolit_encodeBlockAsm:
+        TESTL R9, R9
+        JZ    match_nolit_emitcopy_end_encodeBlockAsm
+        XORL  SI, SI
+        LEAL  -1(SI)(R9*4), R9
+        MOVB  R9, (AX)
+        MOVL  BX, 1(AX)
+        ADDQ  $0x05, AX
+        JMP   match_nolit_emitcopy_end_encodeBlockAsm
+
+two_byte_offset_match_nolit_encodeBlockAsm:
+        CMPL R9, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeBlockAsm
+        CMPL BX, $0x00000800
+        JAE  long_offset_short_match_nolit_encodeBlockAsm
+        MOVL $0x00000001, SI
+        LEAL 16(SI), SI
+        MOVB BL, 1(AX)
+        MOVL BX, DI
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, R9
+
+        // emitRepeat
+        LEAL -4(R9), R9
+        JMP  cant_repeat_two_offset_match_nolit_encodeBlockAsm_emit_copy_short_2b
+
+emit_repeat_again_match_nolit_encodeBlockAsm_emit_copy_short_2b:
+        MOVL R9, SI
+        LEAL -4(R9), R9
+        CMPL SI, $0x08
+        JBE  repeat_two_match_nolit_encodeBlockAsm_emit_copy_short_2b
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBlockAsm_emit_copy_short_2b
+        CMPL BX, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBlockAsm_emit_copy_short_2b
+
+cant_repeat_two_offset_match_nolit_encodeBlockAsm_emit_copy_short_2b:
+        CMPL R9, $0x00000104
+        JB   repeat_three_match_nolit_encodeBlockAsm_emit_copy_short_2b
+        CMPL R9, $0x00010100
+        JB   repeat_four_match_nolit_encodeBlockAsm_emit_copy_short_2b
+        CMPL R9, $0x0100ffff
+        JB   repeat_five_match_nolit_encodeBlockAsm_emit_copy_short_2b
+        LEAL -16842747(R9), R9
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_match_nolit_encodeBlockAsm_emit_copy_short_2b
+
+repeat_five_match_nolit_encodeBlockAsm_emit_copy_short_2b:
+        LEAL -65536(R9), R9
+        MOVL R9, BX
+        MOVW $0x001d, (AX)
+        MOVW R9, 2(AX)
+        SARL $0x10, BX
+        MOVB BL, 4(AX)
+        ADDQ $0x05, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+repeat_four_match_nolit_encodeBlockAsm_emit_copy_short_2b:
+        LEAL -256(R9), R9
+        MOVW $0x0019, (AX)
+        MOVW R9, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+repeat_three_match_nolit_encodeBlockAsm_emit_copy_short_2b:
+        LEAL -4(R9), R9
+        MOVW $0x0015, (AX)
+        MOVB R9, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+repeat_two_match_nolit_encodeBlockAsm_emit_copy_short_2b:
+        SHLL $0x02, R9
+        ORL  $0x01, R9
+        MOVW R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+repeat_two_offset_match_nolit_encodeBlockAsm_emit_copy_short_2b:
+        XORQ SI, SI
+        LEAL 1(SI)(R9*4), R9
+        MOVB BL, 1(AX)
+        SARL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, R9
+        MOVB R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+long_offset_short_match_nolit_encodeBlockAsm:
+        MOVB $0xee, (AX)
+        MOVW BX, 1(AX)
+        LEAL -60(R9), R9
+        ADDQ $0x03, AX
+
+        // emitRepeat
+emit_repeat_again_match_nolit_encodeBlockAsm_emit_copy_short:
+        MOVL R9, SI
+        LEAL -4(R9), R9
+        CMPL SI, $0x08
+        JBE  repeat_two_match_nolit_encodeBlockAsm_emit_copy_short
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBlockAsm_emit_copy_short
+        CMPL BX, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBlockAsm_emit_copy_short
+
+cant_repeat_two_offset_match_nolit_encodeBlockAsm_emit_copy_short:
+        CMPL R9, $0x00000104
+        JB   repeat_three_match_nolit_encodeBlockAsm_emit_copy_short
+        CMPL R9, $0x00010100
+        JB   repeat_four_match_nolit_encodeBlockAsm_emit_copy_short
+        CMPL R9, $0x0100ffff
+        JB   repeat_five_match_nolit_encodeBlockAsm_emit_copy_short
+        LEAL -16842747(R9), R9
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_match_nolit_encodeBlockAsm_emit_copy_short
+
+repeat_five_match_nolit_encodeBlockAsm_emit_copy_short:
+        LEAL -65536(R9), R9
+        MOVL R9, BX
+        MOVW $0x001d, (AX)
+        MOVW R9, 2(AX)
+        SARL $0x10, BX
+        MOVB BL, 4(AX)
+        ADDQ $0x05, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+repeat_four_match_nolit_encodeBlockAsm_emit_copy_short:
+        LEAL -256(R9), R9
+        MOVW $0x0019, (AX)
+        MOVW R9, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+repeat_three_match_nolit_encodeBlockAsm_emit_copy_short:
+        LEAL -4(R9), R9
+        MOVW $0x0015, (AX)
+        MOVB R9, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+repeat_two_match_nolit_encodeBlockAsm_emit_copy_short:
+        SHLL $0x02, R9
+        ORL  $0x01, R9
+        MOVW R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+repeat_two_offset_match_nolit_encodeBlockAsm_emit_copy_short:
+        XORQ SI, SI
+        LEAL 1(SI)(R9*4), R9
+        MOVB BL, 1(AX)
+        SARL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, R9
+        MOVB R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+two_byte_offset_short_match_nolit_encodeBlockAsm:
+        MOVL R9, SI
+        SHLL $0x02, SI
+        CMPL R9, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeBlockAsm
+        CMPL BX, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeBlockAsm
+        LEAL -15(SI), SI
+        MOVB BL, 1(AX)
+        SHRL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm
+
+emit_copy_three_match_nolit_encodeBlockAsm:
+        LEAL -2(SI), SI
+        MOVB SI, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeBlockAsm:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeBlockAsm
+        MOVQ -2(DX)(CX*1), SI
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeBlockAsm
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeBlockAsm:
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  SI, DI
+        SHRQ  $0x10, SI
+        MOVQ  SI, BX
+        SHLQ  $0x10, DI
+        IMULQ R8, DI
+        SHRQ  $0x32, DI
+        SHLQ  $0x10, BX
+        IMULQ R8, BX
+        SHRQ  $0x32, BX
+        LEAL  -2(CX), R8
+        LEAQ  24(SP)(BX*4), R9
+        MOVL  (R9), BX
+        MOVL  R8, 24(SP)(DI*4)
+        MOVL  CX, (R9)
+        CMPL  (DX)(BX*1), SI
+        JEQ   match_nolit_loop_encodeBlockAsm
+        INCL  CX
+        JMP   search_loop_encodeBlockAsm
+
+emit_remainder_encodeBlockAsm:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 5(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeBlockAsm
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeBlockAsm:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeBlockAsm
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeBlockAsm
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeBlockAsm
+        CMPL DX, $0x00010000
+        JB   three_bytes_emit_remainder_encodeBlockAsm
+        CMPL DX, $0x01000000
+        JB   four_bytes_emit_remainder_encodeBlockAsm
+        MOVB $0xfc, (AX)
+        MOVL DX, 1(AX)
+        ADDQ $0x05, AX
+        JMP  memmove_long_emit_remainder_encodeBlockAsm
+
+four_bytes_emit_remainder_encodeBlockAsm:
+        MOVL DX, BX
+        SHRL $0x10, BX
+        MOVB $0xf8, (AX)
+        MOVW DX, 1(AX)
+        MOVB BL, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_emit_remainder_encodeBlockAsm
+
+three_bytes_emit_remainder_encodeBlockAsm:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeBlockAsm
+
+two_bytes_emit_remainder_encodeBlockAsm:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeBlockAsm
+        JMP  memmove_long_emit_remainder_encodeBlockAsm
+
+one_byte_emit_remainder_encodeBlockAsm:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeBlockAsm:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeBlockAsm_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeBlockAsm_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeBlockAsm_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeBlockAsm_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeBlockAsm_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeBlockAsm_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeBlockAsm:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeBlockAsm
+
+memmove_long_emit_remainder_encodeBlockAsm:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeBlockAsmlarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeBlockAsmlarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeBlockAsmlarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeBlockAsmlarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeBlockAsmlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeBlockAsm:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeBlockAsm4MB(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeBlockAsm4MB(SB), $65560-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000200, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeBlockAsm4MB:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeBlockAsm4MB
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  CX, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeBlockAsm4MB:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x06, BX
+        LEAL  4(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeBlockAsm4MB
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHRQ  $0x08, R10
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x32, R9
+        SHLQ  $0x10, R10
+        IMULQ R8, R10
+        SHRQ  $0x32, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  24(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        LEAL  1(CX), R9
+        MOVL  R9, 24(SP)(R10*4)
+        MOVQ  SI, R9
+        SHRQ  $0x10, R9
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x32, R9
+        MOVL  CX, R8
+        SUBL  16(SP), R8
+        MOVL  1(DX)(R8*1), R10
+        MOVQ  SI, R8
+        SHRQ  $0x08, R8
+        CMPL  R8, R10
+        JNE   no_repeat_found_encodeBlockAsm4MB
+        LEAL  1(CX), SI
+        MOVL  12(SP), DI
+        MOVL  SI, BX
+        SUBL  16(SP), BX
+        JZ    repeat_extend_back_end_encodeBlockAsm4MB
+
+repeat_extend_back_loop_encodeBlockAsm4MB:
+        CMPL SI, DI
+        JBE  repeat_extend_back_end_encodeBlockAsm4MB
+        MOVB -1(DX)(BX*1), R8
+        MOVB -1(DX)(SI*1), R9
+        CMPB R8, R9
+        JNE  repeat_extend_back_end_encodeBlockAsm4MB
+        LEAL -1(SI), SI
+        DECL BX
+        JNZ  repeat_extend_back_loop_encodeBlockAsm4MB
+
+repeat_extend_back_end_encodeBlockAsm4MB:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_repeat_emit_encodeBlockAsm4MB
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_repeat_emit_encodeBlockAsm4MB
+        CMPL BX, $0x00000100
+        JB   two_bytes_repeat_emit_encodeBlockAsm4MB
+        CMPL BX, $0x00010000
+        JB   three_bytes_repeat_emit_encodeBlockAsm4MB
+        MOVL BX, R10
+        SHRL $0x10, R10
+        MOVB $0xf8, (AX)
+        MOVW BX, 1(AX)
+        MOVB R10, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_repeat_emit_encodeBlockAsm4MB
+
+three_bytes_repeat_emit_encodeBlockAsm4MB:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_repeat_emit_encodeBlockAsm4MB
+
+two_bytes_repeat_emit_encodeBlockAsm4MB:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_repeat_emit_encodeBlockAsm4MB
+        JMP  memmove_long_repeat_emit_encodeBlockAsm4MB
+
+one_byte_repeat_emit_encodeBlockAsm4MB:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_repeat_emit_encodeBlockAsm4MB:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm4MB_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm4MB_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm4MB_memmove_move_17through32
+        JMP  emit_lit_memmove_repeat_emit_encodeBlockAsm4MB_memmove_move_33through64
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm4MB_memmove_move_8:
+        MOVQ (R9), R10
+        MOVQ R10, (AX)
+        JMP  memmove_end_copy_repeat_emit_encodeBlockAsm4MB
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm4MB_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_repeat_emit_encodeBlockAsm4MB
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm4MB_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_repeat_emit_encodeBlockAsm4MB
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm4MB_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_repeat_emit_encodeBlockAsm4MB:
+        MOVQ BX, AX
+        JMP  emit_literal_done_repeat_emit_encodeBlockAsm4MB
+
+memmove_long_repeat_emit_encodeBlockAsm4MB:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R11
+        SHRQ  $0x05, R11
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R12
+        SUBQ  R10, R12
+        DECQ  R11
+        JA    emit_lit_memmove_long_repeat_emit_encodeBlockAsm4MBlarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R12*1), R10
+        LEAQ  -32(AX)(R12*1), R13
+
+emit_lit_memmove_long_repeat_emit_encodeBlockAsm4MBlarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R13)
+        MOVOA X5, 16(R13)
+        ADDQ  $0x20, R13
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R12
+        DECQ  R11
+        JNA   emit_lit_memmove_long_repeat_emit_encodeBlockAsm4MBlarge_big_loop_back
+
+emit_lit_memmove_long_repeat_emit_encodeBlockAsm4MBlarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R12*1), X4
+        MOVOU -16(R9)(R12*1), X5
+        MOVOA X4, -32(AX)(R12*1)
+        MOVOA X5, -16(AX)(R12*1)
+        ADDQ  $0x20, R12
+        CMPQ  R8, R12
+        JAE   emit_lit_memmove_long_repeat_emit_encodeBlockAsm4MBlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_repeat_emit_encodeBlockAsm4MB:
+        ADDL $0x05, CX
+        MOVL CX, BX
+        SUBL 16(SP), BX
+        MOVQ src_len+32(FP), R8
+        SUBL CX, R8
+        LEAQ (DX)(CX*1), R9
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_repeat_extend_encodeBlockAsm4MB:
+        CMPL R8, $0x10
+        JB   matchlen_match8_repeat_extend_encodeBlockAsm4MB
+        MOVQ (R9)(R11*1), R10
+        MOVQ 8(R9)(R11*1), R12
+        XORQ (BX)(R11*1), R10
+        JNZ  matchlen_bsf_8_repeat_extend_encodeBlockAsm4MB
+        XORQ 8(BX)(R11*1), R12
+        JNZ  matchlen_bsf_16repeat_extend_encodeBlockAsm4MB
+        LEAL -16(R8), R8
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_repeat_extend_encodeBlockAsm4MB
+
+matchlen_bsf_16repeat_extend_encodeBlockAsm4MB:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  repeat_extend_forward_end_encodeBlockAsm4MB
+
+matchlen_match8_repeat_extend_encodeBlockAsm4MB:
+        CMPL R8, $0x08
+        JB   matchlen_match4_repeat_extend_encodeBlockAsm4MB
+        MOVQ (R9)(R11*1), R10
+        XORQ (BX)(R11*1), R10
+        JNZ  matchlen_bsf_8_repeat_extend_encodeBlockAsm4MB
+        LEAL -8(R8), R8
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_repeat_extend_encodeBlockAsm4MB
+
+matchlen_bsf_8_repeat_extend_encodeBlockAsm4MB:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  repeat_extend_forward_end_encodeBlockAsm4MB
+
+matchlen_match4_repeat_extend_encodeBlockAsm4MB:
+        CMPL R8, $0x04
+        JB   matchlen_match2_repeat_extend_encodeBlockAsm4MB
+        MOVL (R9)(R11*1), R10
+        CMPL (BX)(R11*1), R10
+        JNE  matchlen_match2_repeat_extend_encodeBlockAsm4MB
+        LEAL -4(R8), R8
+        LEAL 4(R11), R11
+
+matchlen_match2_repeat_extend_encodeBlockAsm4MB:
+        CMPL R8, $0x01
+        JE   matchlen_match1_repeat_extend_encodeBlockAsm4MB
+        JB   repeat_extend_forward_end_encodeBlockAsm4MB
+        MOVW (R9)(R11*1), R10
+        CMPW (BX)(R11*1), R10
+        JNE  matchlen_match1_repeat_extend_encodeBlockAsm4MB
+        LEAL 2(R11), R11
+        SUBL $0x02, R8
+        JZ   repeat_extend_forward_end_encodeBlockAsm4MB
+
+matchlen_match1_repeat_extend_encodeBlockAsm4MB:
+        MOVB (R9)(R11*1), R10
+        CMPB (BX)(R11*1), R10
+        JNE  repeat_extend_forward_end_encodeBlockAsm4MB
+        LEAL 1(R11), R11
+
+repeat_extend_forward_end_encodeBlockAsm4MB:
+        ADDL  R11, CX
+        MOVL  CX, BX
+        SUBL  SI, BX
+        MOVL  16(SP), SI
+        TESTL DI, DI
+        JZ    repeat_as_copy_encodeBlockAsm4MB
+
+        // emitRepeat
+        MOVL BX, DI
+        LEAL -4(BX), BX
+        CMPL DI, $0x08
+        JBE  repeat_two_match_repeat_encodeBlockAsm4MB
+        CMPL DI, $0x0c
+        JAE  cant_repeat_two_offset_match_repeat_encodeBlockAsm4MB
+        CMPL SI, $0x00000800
+        JB   repeat_two_offset_match_repeat_encodeBlockAsm4MB
+
+cant_repeat_two_offset_match_repeat_encodeBlockAsm4MB:
+        CMPL BX, $0x00000104
+        JB   repeat_three_match_repeat_encodeBlockAsm4MB
+        CMPL BX, $0x00010100
+        JB   repeat_four_match_repeat_encodeBlockAsm4MB
+        LEAL -65536(BX), BX
+        MOVL BX, SI
+        MOVW $0x001d, (AX)
+        MOVW BX, 2(AX)
+        SARL $0x10, SI
+        MOVB SI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_four_match_repeat_encodeBlockAsm4MB:
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_three_match_repeat_encodeBlockAsm4MB:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_two_match_repeat_encodeBlockAsm4MB:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_two_offset_match_repeat_encodeBlockAsm4MB:
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_as_copy_encodeBlockAsm4MB:
+        // emitCopy
+        CMPL SI, $0x00010000
+        JB   two_byte_offset_repeat_as_copy_encodeBlockAsm4MB
+        CMPL BX, $0x40
+        JBE  four_bytes_remain_repeat_as_copy_encodeBlockAsm4MB
+        MOVB $0xff, (AX)
+        MOVL SI, 1(AX)
+        LEAL -64(BX), BX
+        ADDQ $0x05, AX
+        CMPL BX, $0x04
+        JB   four_bytes_remain_repeat_as_copy_encodeBlockAsm4MB
+
+        // emitRepeat
+        MOVL BX, DI
+        LEAL -4(BX), BX
+        CMPL DI, $0x08
+        JBE  repeat_two_repeat_as_copy_encodeBlockAsm4MB_emit_copy
+        CMPL DI, $0x0c
+        JAE  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm4MB_emit_copy
+        CMPL SI, $0x00000800
+        JB   repeat_two_offset_repeat_as_copy_encodeBlockAsm4MB_emit_copy
+
+cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm4MB_emit_copy:
+        CMPL BX, $0x00000104
+        JB   repeat_three_repeat_as_copy_encodeBlockAsm4MB_emit_copy
+        CMPL BX, $0x00010100
+        JB   repeat_four_repeat_as_copy_encodeBlockAsm4MB_emit_copy
+        LEAL -65536(BX), BX
+        MOVL BX, SI
+        MOVW $0x001d, (AX)
+        MOVW BX, 2(AX)
+        SARL $0x10, SI
+        MOVB SI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_four_repeat_as_copy_encodeBlockAsm4MB_emit_copy:
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_three_repeat_as_copy_encodeBlockAsm4MB_emit_copy:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_two_repeat_as_copy_encodeBlockAsm4MB_emit_copy:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_two_offset_repeat_as_copy_encodeBlockAsm4MB_emit_copy:
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+four_bytes_remain_repeat_as_copy_encodeBlockAsm4MB:
+        TESTL BX, BX
+        JZ    repeat_end_emit_encodeBlockAsm4MB
+        XORL  DI, DI
+        LEAL  -1(DI)(BX*4), BX
+        MOVB  BL, (AX)
+        MOVL  SI, 1(AX)
+        ADDQ  $0x05, AX
+        JMP   repeat_end_emit_encodeBlockAsm4MB
+
+two_byte_offset_repeat_as_copy_encodeBlockAsm4MB:
+        CMPL BX, $0x40
+        JBE  two_byte_offset_short_repeat_as_copy_encodeBlockAsm4MB
+        CMPL SI, $0x00000800
+        JAE  long_offset_short_repeat_as_copy_encodeBlockAsm4MB
+        MOVL $0x00000001, DI
+        LEAL 16(DI), DI
+        MOVB SI, 1(AX)
+        SHRL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, BX
+
+        // emitRepeat
+        LEAL -4(BX), BX
+        JMP  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short_2b
+        MOVL BX, DI
+        LEAL -4(BX), BX
+        CMPL DI, $0x08
+        JBE  repeat_two_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short_2b
+        CMPL DI, $0x0c
+        JAE  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short_2b
+        CMPL SI, $0x00000800
+        JB   repeat_two_offset_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short_2b
+
+cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short_2b:
+        CMPL BX, $0x00000104
+        JB   repeat_three_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short_2b
+        CMPL BX, $0x00010100
+        JB   repeat_four_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short_2b
+        LEAL -65536(BX), BX
+        MOVL BX, SI
+        MOVW $0x001d, (AX)
+        MOVW BX, 2(AX)
+        SARL $0x10, SI
+        MOVB SI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_four_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short_2b:
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_three_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short_2b:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_two_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short_2b:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_two_offset_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short_2b:
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+long_offset_short_repeat_as_copy_encodeBlockAsm4MB:
+        MOVB $0xee, (AX)
+        MOVW SI, 1(AX)
+        LEAL -60(BX), BX
+        ADDQ $0x03, AX
+
+        // emitRepeat
+        MOVL BX, DI
+        LEAL -4(BX), BX
+        CMPL DI, $0x08
+        JBE  repeat_two_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short
+        CMPL DI, $0x0c
+        JAE  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short
+        CMPL SI, $0x00000800
+        JB   repeat_two_offset_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short
+
+cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short:
+        CMPL BX, $0x00000104
+        JB   repeat_three_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short
+        CMPL BX, $0x00010100
+        JB   repeat_four_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short
+        LEAL -65536(BX), BX
+        MOVL BX, SI
+        MOVW $0x001d, (AX)
+        MOVW BX, 2(AX)
+        SARL $0x10, SI
+        MOVB SI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_four_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short:
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_three_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_two_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+repeat_two_offset_repeat_as_copy_encodeBlockAsm4MB_emit_copy_short:
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+two_byte_offset_short_repeat_as_copy_encodeBlockAsm4MB:
+        MOVL BX, DI
+        SHLL $0x02, DI
+        CMPL BX, $0x0c
+        JAE  emit_copy_three_repeat_as_copy_encodeBlockAsm4MB
+        CMPL SI, $0x00000800
+        JAE  emit_copy_three_repeat_as_copy_encodeBlockAsm4MB
+        LEAL -15(DI), DI
+        MOVB SI, 1(AX)
+        SHRL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm4MB
+
+emit_copy_three_repeat_as_copy_encodeBlockAsm4MB:
+        LEAL -2(DI), DI
+        MOVB DI, (AX)
+        MOVW SI, 1(AX)
+        ADDQ $0x03, AX
+
+repeat_end_emit_encodeBlockAsm4MB:
+        MOVL CX, 12(SP)
+        JMP  search_loop_encodeBlockAsm4MB
+
+no_repeat_found_encodeBlockAsm4MB:
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate_match_encodeBlockAsm4MB
+        SHRQ $0x08, SI
+        MOVL 24(SP)(R9*4), BX
+        LEAL 2(CX), R8
+        CMPL (DX)(DI*1), SI
+        JEQ  candidate2_match_encodeBlockAsm4MB
+        MOVL R8, 24(SP)(R9*4)
+        SHRQ $0x08, SI
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate3_match_encodeBlockAsm4MB
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeBlockAsm4MB
+
+candidate3_match_encodeBlockAsm4MB:
+        ADDL $0x02, CX
+        JMP  candidate_match_encodeBlockAsm4MB
+
+candidate2_match_encodeBlockAsm4MB:
+        MOVL R8, 24(SP)(R9*4)
+        INCL CX
+        MOVL DI, BX
+
+candidate_match_encodeBlockAsm4MB:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeBlockAsm4MB
+
+match_extend_back_loop_encodeBlockAsm4MB:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeBlockAsm4MB
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeBlockAsm4MB
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeBlockAsm4MB
+        JMP  match_extend_back_loop_encodeBlockAsm4MB
+
+match_extend_back_end_encodeBlockAsm4MB:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 4(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeBlockAsm4MB
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeBlockAsm4MB:
+        MOVL CX, SI
+        MOVL 12(SP), DI
+        CMPL DI, SI
+        JEQ  emit_literal_done_match_emit_encodeBlockAsm4MB
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(DI*1), SI
+        SUBL DI, R8
+        LEAL -1(R8), DI
+        CMPL DI, $0x3c
+        JB   one_byte_match_emit_encodeBlockAsm4MB
+        CMPL DI, $0x00000100
+        JB   two_bytes_match_emit_encodeBlockAsm4MB
+        CMPL DI, $0x00010000
+        JB   three_bytes_match_emit_encodeBlockAsm4MB
+        MOVL DI, R9
+        SHRL $0x10, R9
+        MOVB $0xf8, (AX)
+        MOVW DI, 1(AX)
+        MOVB R9, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_match_emit_encodeBlockAsm4MB
+
+three_bytes_match_emit_encodeBlockAsm4MB:
+        MOVB $0xf4, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeBlockAsm4MB
+
+two_bytes_match_emit_encodeBlockAsm4MB:
+        MOVB $0xf0, (AX)
+        MOVB DI, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DI, $0x40
+        JB   memmove_match_emit_encodeBlockAsm4MB
+        JMP  memmove_long_match_emit_encodeBlockAsm4MB
+
+one_byte_match_emit_encodeBlockAsm4MB:
+        SHLB $0x02, DI
+        MOVB DI, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeBlockAsm4MB:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm4MB_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm4MB_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm4MB_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeBlockAsm4MB_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeBlockAsm4MB_memmove_move_8:
+        MOVQ (SI), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_match_emit_encodeBlockAsm4MB
+
+emit_lit_memmove_match_emit_encodeBlockAsm4MB_memmove_move_8through16:
+        MOVQ (SI), R9
+        MOVQ -8(SI)(R8*1), SI
+        MOVQ R9, (AX)
+        MOVQ SI, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBlockAsm4MB
+
+emit_lit_memmove_match_emit_encodeBlockAsm4MB_memmove_move_17through32:
+        MOVOU (SI), X0
+        MOVOU -16(SI)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeBlockAsm4MB
+
+emit_lit_memmove_match_emit_encodeBlockAsm4MB_memmove_move_33through64:
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeBlockAsm4MB:
+        MOVQ DI, AX
+        JMP  emit_literal_done_match_emit_encodeBlockAsm4MB
+
+memmove_long_match_emit_encodeBlockAsm4MB:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveLong
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVQ  R8, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_match_emit_encodeBlockAsm4MBlarge_forward_sse_loop_32
+        LEAQ  -32(SI)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_match_emit_encodeBlockAsm4MBlarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_match_emit_encodeBlockAsm4MBlarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeBlockAsm4MBlarge_forward_sse_loop_32:
+        MOVOU -32(SI)(R11*1), X4
+        MOVOU -16(SI)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  R8, R11
+        JAE   emit_lit_memmove_long_match_emit_encodeBlockAsm4MBlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  DI, AX
+
+emit_literal_done_match_emit_encodeBlockAsm4MB:
+match_nolit_loop_encodeBlockAsm4MB:
+        MOVL CX, SI
+        SUBL BX, SI
+        MOVL SI, 16(SP)
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), SI
+        SUBL CX, SI
+        LEAQ (DX)(CX*1), DI
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R9, R9
+
+matchlen_loopback_16_match_nolit_encodeBlockAsm4MB:
+        CMPL SI, $0x10
+        JB   matchlen_match8_match_nolit_encodeBlockAsm4MB
+        MOVQ (DI)(R9*1), R8
+        MOVQ 8(DI)(R9*1), R10
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeBlockAsm4MB
+        XORQ 8(BX)(R9*1), R10
+        JNZ  matchlen_bsf_16match_nolit_encodeBlockAsm4MB
+        LEAL -16(SI), SI
+        LEAL 16(R9), R9
+        JMP  matchlen_loopback_16_match_nolit_encodeBlockAsm4MB
+
+matchlen_bsf_16match_nolit_encodeBlockAsm4MB:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL 8(R9)(R10*1), R9
+        JMP  match_nolit_end_encodeBlockAsm4MB
+
+matchlen_match8_match_nolit_encodeBlockAsm4MB:
+        CMPL SI, $0x08
+        JB   matchlen_match4_match_nolit_encodeBlockAsm4MB
+        MOVQ (DI)(R9*1), R8
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeBlockAsm4MB
+        LEAL -8(SI), SI
+        LEAL 8(R9), R9
+        JMP  matchlen_match4_match_nolit_encodeBlockAsm4MB
+
+matchlen_bsf_8_match_nolit_encodeBlockAsm4MB:
+#ifdef GOAMD64_v3
+        TZCNTQ R8, R8
+
+#else
+        BSFQ R8, R8
+
+#endif
+        SARQ $0x03, R8
+        LEAL (R9)(R8*1), R9
+        JMP  match_nolit_end_encodeBlockAsm4MB
+
+matchlen_match4_match_nolit_encodeBlockAsm4MB:
+        CMPL SI, $0x04
+        JB   matchlen_match2_match_nolit_encodeBlockAsm4MB
+        MOVL (DI)(R9*1), R8
+        CMPL (BX)(R9*1), R8
+        JNE  matchlen_match2_match_nolit_encodeBlockAsm4MB
+        LEAL -4(SI), SI
+        LEAL 4(R9), R9
+
+matchlen_match2_match_nolit_encodeBlockAsm4MB:
+        CMPL SI, $0x01
+        JE   matchlen_match1_match_nolit_encodeBlockAsm4MB
+        JB   match_nolit_end_encodeBlockAsm4MB
+        MOVW (DI)(R9*1), R8
+        CMPW (BX)(R9*1), R8
+        JNE  matchlen_match1_match_nolit_encodeBlockAsm4MB
+        LEAL 2(R9), R9
+        SUBL $0x02, SI
+        JZ   match_nolit_end_encodeBlockAsm4MB
+
+matchlen_match1_match_nolit_encodeBlockAsm4MB:
+        MOVB (DI)(R9*1), R8
+        CMPB (BX)(R9*1), R8
+        JNE  match_nolit_end_encodeBlockAsm4MB
+        LEAL 1(R9), R9
+
+match_nolit_end_encodeBlockAsm4MB:
+        ADDL R9, CX
+        MOVL 16(SP), BX
+        ADDL $0x04, R9
+        MOVL CX, 12(SP)
+
+        // emitCopy
+        CMPL BX, $0x00010000
+        JB   two_byte_offset_match_nolit_encodeBlockAsm4MB
+        CMPL R9, $0x40
+        JBE  four_bytes_remain_match_nolit_encodeBlockAsm4MB
+        MOVB $0xff, (AX)
+        MOVL BX, 1(AX)
+        LEAL -64(R9), R9
+        ADDQ $0x05, AX
+        CMPL R9, $0x04
+        JB   four_bytes_remain_match_nolit_encodeBlockAsm4MB
+
+        // emitRepeat
+        MOVL R9, SI
+        LEAL -4(R9), R9
+        CMPL SI, $0x08
+        JBE  repeat_two_match_nolit_encodeBlockAsm4MB_emit_copy
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBlockAsm4MB_emit_copy
+        CMPL BX, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBlockAsm4MB_emit_copy
+
+cant_repeat_two_offset_match_nolit_encodeBlockAsm4MB_emit_copy:
+        CMPL R9, $0x00000104
+        JB   repeat_three_match_nolit_encodeBlockAsm4MB_emit_copy
+        CMPL R9, $0x00010100
+        JB   repeat_four_match_nolit_encodeBlockAsm4MB_emit_copy
+        LEAL -65536(R9), R9
+        MOVL R9, BX
+        MOVW $0x001d, (AX)
+        MOVW R9, 2(AX)
+        SARL $0x10, BX
+        MOVB BL, 4(AX)
+        ADDQ $0x05, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+repeat_four_match_nolit_encodeBlockAsm4MB_emit_copy:
+        LEAL -256(R9), R9
+        MOVW $0x0019, (AX)
+        MOVW R9, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+repeat_three_match_nolit_encodeBlockAsm4MB_emit_copy:
+        LEAL -4(R9), R9
+        MOVW $0x0015, (AX)
+        MOVB R9, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+repeat_two_match_nolit_encodeBlockAsm4MB_emit_copy:
+        SHLL $0x02, R9
+        ORL  $0x01, R9
+        MOVW R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+repeat_two_offset_match_nolit_encodeBlockAsm4MB_emit_copy:
+        XORQ SI, SI
+        LEAL 1(SI)(R9*4), R9
+        MOVB BL, 1(AX)
+        SARL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, R9
+        MOVB R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+four_bytes_remain_match_nolit_encodeBlockAsm4MB:
+        TESTL R9, R9
+        JZ    match_nolit_emitcopy_end_encodeBlockAsm4MB
+        XORL  SI, SI
+        LEAL  -1(SI)(R9*4), R9
+        MOVB  R9, (AX)
+        MOVL  BX, 1(AX)
+        ADDQ  $0x05, AX
+        JMP   match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+two_byte_offset_match_nolit_encodeBlockAsm4MB:
+        CMPL R9, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeBlockAsm4MB
+        CMPL BX, $0x00000800
+        JAE  long_offset_short_match_nolit_encodeBlockAsm4MB
+        MOVL $0x00000001, SI
+        LEAL 16(SI), SI
+        MOVB BL, 1(AX)
+        SHRL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, R9
+
+        // emitRepeat
+        LEAL -4(R9), R9
+        JMP  cant_repeat_two_offset_match_nolit_encodeBlockAsm4MB_emit_copy_short_2b
+        MOVL R9, SI
+        LEAL -4(R9), R9
+        CMPL SI, $0x08
+        JBE  repeat_two_match_nolit_encodeBlockAsm4MB_emit_copy_short_2b
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBlockAsm4MB_emit_copy_short_2b
+        CMPL BX, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBlockAsm4MB_emit_copy_short_2b
+
+cant_repeat_two_offset_match_nolit_encodeBlockAsm4MB_emit_copy_short_2b:
+        CMPL R9, $0x00000104
+        JB   repeat_three_match_nolit_encodeBlockAsm4MB_emit_copy_short_2b
+        CMPL R9, $0x00010100
+        JB   repeat_four_match_nolit_encodeBlockAsm4MB_emit_copy_short_2b
+        LEAL -65536(R9), R9
+        MOVL R9, BX
+        MOVW $0x001d, (AX)
+        MOVW R9, 2(AX)
+        SARL $0x10, BX
+        MOVB BL, 4(AX)
+        ADDQ $0x05, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+repeat_four_match_nolit_encodeBlockAsm4MB_emit_copy_short_2b:
+        LEAL -256(R9), R9
+        MOVW $0x0019, (AX)
+        MOVW R9, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+repeat_three_match_nolit_encodeBlockAsm4MB_emit_copy_short_2b:
+        LEAL -4(R9), R9
+        MOVW $0x0015, (AX)
+        MOVB R9, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+repeat_two_match_nolit_encodeBlockAsm4MB_emit_copy_short_2b:
+        SHLL $0x02, R9
+        ORL  $0x01, R9
+        MOVW R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+repeat_two_offset_match_nolit_encodeBlockAsm4MB_emit_copy_short_2b:
+        XORQ SI, SI
+        LEAL 1(SI)(R9*4), R9
+        MOVB BL, 1(AX)
+        SARL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, R9
+        MOVB R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+long_offset_short_match_nolit_encodeBlockAsm4MB:
+        MOVB $0xee, (AX)
+        MOVW BX, 1(AX)
+        LEAL -60(R9), R9
+        ADDQ $0x03, AX
+
+        // emitRepeat
+        MOVL R9, SI
+        LEAL -4(R9), R9
+        CMPL SI, $0x08
+        JBE  repeat_two_match_nolit_encodeBlockAsm4MB_emit_copy_short
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBlockAsm4MB_emit_copy_short
+        CMPL BX, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBlockAsm4MB_emit_copy_short
+
+cant_repeat_two_offset_match_nolit_encodeBlockAsm4MB_emit_copy_short:
+        CMPL R9, $0x00000104
+        JB   repeat_three_match_nolit_encodeBlockAsm4MB_emit_copy_short
+        CMPL R9, $0x00010100
+        JB   repeat_four_match_nolit_encodeBlockAsm4MB_emit_copy_short
+        LEAL -65536(R9), R9
+        MOVL R9, BX
+        MOVW $0x001d, (AX)
+        MOVW R9, 2(AX)
+        SARL $0x10, BX
+        MOVB BL, 4(AX)
+        ADDQ $0x05, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+repeat_four_match_nolit_encodeBlockAsm4MB_emit_copy_short:
+        LEAL -256(R9), R9
+        MOVW $0x0019, (AX)
+        MOVW R9, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+repeat_three_match_nolit_encodeBlockAsm4MB_emit_copy_short:
+        LEAL -4(R9), R9
+        MOVW $0x0015, (AX)
+        MOVB R9, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+repeat_two_match_nolit_encodeBlockAsm4MB_emit_copy_short:
+        SHLL $0x02, R9
+        ORL  $0x01, R9
+        MOVW R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+repeat_two_offset_match_nolit_encodeBlockAsm4MB_emit_copy_short:
+        XORQ SI, SI
+        LEAL 1(SI)(R9*4), R9
+        MOVB BL, 1(AX)
+        SARL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, R9
+        MOVB R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+two_byte_offset_short_match_nolit_encodeBlockAsm4MB:
+        MOVL R9, SI
+        SHLL $0x02, SI
+        CMPL R9, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeBlockAsm4MB
+        CMPL BX, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeBlockAsm4MB
+        LEAL -15(SI), SI
+        MOVB BL, 1(AX)
+        SHRL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm4MB
+
+emit_copy_three_match_nolit_encodeBlockAsm4MB:
+        LEAL -2(SI), SI
+        MOVB SI, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeBlockAsm4MB:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeBlockAsm4MB
+        MOVQ -2(DX)(CX*1), SI
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeBlockAsm4MB
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeBlockAsm4MB:
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  SI, DI
+        SHRQ  $0x10, SI
+        MOVQ  SI, BX
+        SHLQ  $0x10, DI
+        IMULQ R8, DI
+        SHRQ  $0x32, DI
+        SHLQ  $0x10, BX
+        IMULQ R8, BX
+        SHRQ  $0x32, BX
+        LEAL  -2(CX), R8
+        LEAQ  24(SP)(BX*4), R9
+        MOVL  (R9), BX
+        MOVL  R8, 24(SP)(DI*4)
+        MOVL  CX, (R9)
+        CMPL  (DX)(BX*1), SI
+        JEQ   match_nolit_loop_encodeBlockAsm4MB
+        INCL  CX
+        JMP   search_loop_encodeBlockAsm4MB
+
+emit_remainder_encodeBlockAsm4MB:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 4(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeBlockAsm4MB
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeBlockAsm4MB:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeBlockAsm4MB
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeBlockAsm4MB
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeBlockAsm4MB
+        CMPL DX, $0x00010000
+        JB   three_bytes_emit_remainder_encodeBlockAsm4MB
+        MOVL DX, BX
+        SHRL $0x10, BX
+        MOVB $0xf8, (AX)
+        MOVW DX, 1(AX)
+        MOVB BL, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_emit_remainder_encodeBlockAsm4MB
+
+three_bytes_emit_remainder_encodeBlockAsm4MB:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeBlockAsm4MB
+
+two_bytes_emit_remainder_encodeBlockAsm4MB:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeBlockAsm4MB
+        JMP  memmove_long_emit_remainder_encodeBlockAsm4MB
+
+one_byte_emit_remainder_encodeBlockAsm4MB:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeBlockAsm4MB:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeBlockAsm4MB_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeBlockAsm4MB_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeBlockAsm4MB_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeBlockAsm4MB_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeBlockAsm4MB_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeBlockAsm4MB_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm4MB_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm4MB
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm4MB_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm4MB
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm4MB_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm4MB
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm4MB_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm4MB
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm4MB_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeBlockAsm4MB
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm4MB_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeBlockAsm4MB:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeBlockAsm4MB
+
+memmove_long_emit_remainder_encodeBlockAsm4MB:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeBlockAsm4MBlarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeBlockAsm4MBlarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeBlockAsm4MBlarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeBlockAsm4MBlarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeBlockAsm4MBlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeBlockAsm4MB:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeBlockAsm12B(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeBlockAsm12B(SB), $16408-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000080, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeBlockAsm12B:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeBlockAsm12B
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  CX, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeBlockAsm12B:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x05, BX
+        LEAL  4(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeBlockAsm12B
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x000000cf1bbcdcbb, R8
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHRQ  $0x08, R10
+        SHLQ  $0x18, R9
+        IMULQ R8, R9
+        SHRQ  $0x34, R9
+        SHLQ  $0x18, R10
+        IMULQ R8, R10
+        SHRQ  $0x34, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  24(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        LEAL  1(CX), R9
+        MOVL  R9, 24(SP)(R10*4)
+        MOVQ  SI, R9
+        SHRQ  $0x10, R9
+        SHLQ  $0x18, R9
+        IMULQ R8, R9
+        SHRQ  $0x34, R9
+        MOVL  CX, R8
+        SUBL  16(SP), R8
+        MOVL  1(DX)(R8*1), R10
+        MOVQ  SI, R8
+        SHRQ  $0x08, R8
+        CMPL  R8, R10
+        JNE   no_repeat_found_encodeBlockAsm12B
+        LEAL  1(CX), SI
+        MOVL  12(SP), DI
+        MOVL  SI, BX
+        SUBL  16(SP), BX
+        JZ    repeat_extend_back_end_encodeBlockAsm12B
+
+repeat_extend_back_loop_encodeBlockAsm12B:
+        CMPL SI, DI
+        JBE  repeat_extend_back_end_encodeBlockAsm12B
+        MOVB -1(DX)(BX*1), R8
+        MOVB -1(DX)(SI*1), R9
+        CMPB R8, R9
+        JNE  repeat_extend_back_end_encodeBlockAsm12B
+        LEAL -1(SI), SI
+        DECL BX
+        JNZ  repeat_extend_back_loop_encodeBlockAsm12B
+
+repeat_extend_back_end_encodeBlockAsm12B:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_repeat_emit_encodeBlockAsm12B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_repeat_emit_encodeBlockAsm12B
+        CMPL BX, $0x00000100
+        JB   two_bytes_repeat_emit_encodeBlockAsm12B
+        JB   three_bytes_repeat_emit_encodeBlockAsm12B
+
+three_bytes_repeat_emit_encodeBlockAsm12B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_repeat_emit_encodeBlockAsm12B
+
+two_bytes_repeat_emit_encodeBlockAsm12B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_repeat_emit_encodeBlockAsm12B
+        JMP  memmove_long_repeat_emit_encodeBlockAsm12B
+
+one_byte_repeat_emit_encodeBlockAsm12B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_repeat_emit_encodeBlockAsm12B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm12B_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm12B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm12B_memmove_move_17through32
+        JMP  emit_lit_memmove_repeat_emit_encodeBlockAsm12B_memmove_move_33through64
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm12B_memmove_move_8:
+        MOVQ (R9), R10
+        MOVQ R10, (AX)
+        JMP  memmove_end_copy_repeat_emit_encodeBlockAsm12B
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm12B_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_repeat_emit_encodeBlockAsm12B
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm12B_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_repeat_emit_encodeBlockAsm12B
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm12B_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_repeat_emit_encodeBlockAsm12B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_repeat_emit_encodeBlockAsm12B
+
+memmove_long_repeat_emit_encodeBlockAsm12B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R11
+        SHRQ  $0x05, R11
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R12
+        SUBQ  R10, R12
+        DECQ  R11
+        JA    emit_lit_memmove_long_repeat_emit_encodeBlockAsm12Blarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R12*1), R10
+        LEAQ  -32(AX)(R12*1), R13
+
+emit_lit_memmove_long_repeat_emit_encodeBlockAsm12Blarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R13)
+        MOVOA X5, 16(R13)
+        ADDQ  $0x20, R13
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R12
+        DECQ  R11
+        JNA   emit_lit_memmove_long_repeat_emit_encodeBlockAsm12Blarge_big_loop_back
+
+emit_lit_memmove_long_repeat_emit_encodeBlockAsm12Blarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R12*1), X4
+        MOVOU -16(R9)(R12*1), X5
+        MOVOA X4, -32(AX)(R12*1)
+        MOVOA X5, -16(AX)(R12*1)
+        ADDQ  $0x20, R12
+        CMPQ  R8, R12
+        JAE   emit_lit_memmove_long_repeat_emit_encodeBlockAsm12Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_repeat_emit_encodeBlockAsm12B:
+        ADDL $0x05, CX
+        MOVL CX, BX
+        SUBL 16(SP), BX
+        MOVQ src_len+32(FP), R8
+        SUBL CX, R8
+        LEAQ (DX)(CX*1), R9
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_repeat_extend_encodeBlockAsm12B:
+        CMPL R8, $0x10
+        JB   matchlen_match8_repeat_extend_encodeBlockAsm12B
+        MOVQ (R9)(R11*1), R10
+        MOVQ 8(R9)(R11*1), R12
+        XORQ (BX)(R11*1), R10
+        JNZ  matchlen_bsf_8_repeat_extend_encodeBlockAsm12B
+        XORQ 8(BX)(R11*1), R12
+        JNZ  matchlen_bsf_16repeat_extend_encodeBlockAsm12B
+        LEAL -16(R8), R8
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_repeat_extend_encodeBlockAsm12B
+
+matchlen_bsf_16repeat_extend_encodeBlockAsm12B:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  repeat_extend_forward_end_encodeBlockAsm12B
+
+matchlen_match8_repeat_extend_encodeBlockAsm12B:
+        CMPL R8, $0x08
+        JB   matchlen_match4_repeat_extend_encodeBlockAsm12B
+        MOVQ (R9)(R11*1), R10
+        XORQ (BX)(R11*1), R10
+        JNZ  matchlen_bsf_8_repeat_extend_encodeBlockAsm12B
+        LEAL -8(R8), R8
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_repeat_extend_encodeBlockAsm12B
+
+matchlen_bsf_8_repeat_extend_encodeBlockAsm12B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  repeat_extend_forward_end_encodeBlockAsm12B
+
+matchlen_match4_repeat_extend_encodeBlockAsm12B:
+        CMPL R8, $0x04
+        JB   matchlen_match2_repeat_extend_encodeBlockAsm12B
+        MOVL (R9)(R11*1), R10
+        CMPL (BX)(R11*1), R10
+        JNE  matchlen_match2_repeat_extend_encodeBlockAsm12B
+        LEAL -4(R8), R8
+        LEAL 4(R11), R11
+
+matchlen_match2_repeat_extend_encodeBlockAsm12B:
+        CMPL R8, $0x01
+        JE   matchlen_match1_repeat_extend_encodeBlockAsm12B
+        JB   repeat_extend_forward_end_encodeBlockAsm12B
+        MOVW (R9)(R11*1), R10
+        CMPW (BX)(R11*1), R10
+        JNE  matchlen_match1_repeat_extend_encodeBlockAsm12B
+        LEAL 2(R11), R11
+        SUBL $0x02, R8
+        JZ   repeat_extend_forward_end_encodeBlockAsm12B
+
+matchlen_match1_repeat_extend_encodeBlockAsm12B:
+        MOVB (R9)(R11*1), R10
+        CMPB (BX)(R11*1), R10
+        JNE  repeat_extend_forward_end_encodeBlockAsm12B
+        LEAL 1(R11), R11
+
+repeat_extend_forward_end_encodeBlockAsm12B:
+        ADDL  R11, CX
+        MOVL  CX, BX
+        SUBL  SI, BX
+        MOVL  16(SP), SI
+        TESTL DI, DI
+        JZ    repeat_as_copy_encodeBlockAsm12B
+
+        // emitRepeat
+        MOVL BX, DI
+        LEAL -4(BX), BX
+        CMPL DI, $0x08
+        JBE  repeat_two_match_repeat_encodeBlockAsm12B
+        CMPL DI, $0x0c
+        JAE  cant_repeat_two_offset_match_repeat_encodeBlockAsm12B
+        CMPL SI, $0x00000800
+        JB   repeat_two_offset_match_repeat_encodeBlockAsm12B
+
+cant_repeat_two_offset_match_repeat_encodeBlockAsm12B:
+        CMPL BX, $0x00000104
+        JB   repeat_three_match_repeat_encodeBlockAsm12B
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm12B
+
+repeat_three_match_repeat_encodeBlockAsm12B:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm12B
+
+repeat_two_match_repeat_encodeBlockAsm12B:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm12B
+
+repeat_two_offset_match_repeat_encodeBlockAsm12B:
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm12B
+
+repeat_as_copy_encodeBlockAsm12B:
+        // emitCopy
+        CMPL BX, $0x40
+        JBE  two_byte_offset_short_repeat_as_copy_encodeBlockAsm12B
+        CMPL SI, $0x00000800
+        JAE  long_offset_short_repeat_as_copy_encodeBlockAsm12B
+        MOVL $0x00000001, DI
+        LEAL 16(DI), DI
+        MOVB SI, 1(AX)
+        SHRL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, BX
+
+        // emitRepeat
+        LEAL -4(BX), BX
+        JMP  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm12B_emit_copy_short_2b
+        MOVL BX, DI
+        LEAL -4(BX), BX
+        CMPL DI, $0x08
+        JBE  repeat_two_repeat_as_copy_encodeBlockAsm12B_emit_copy_short_2b
+        CMPL DI, $0x0c
+        JAE  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm12B_emit_copy_short_2b
+        CMPL SI, $0x00000800
+        JB   repeat_two_offset_repeat_as_copy_encodeBlockAsm12B_emit_copy_short_2b
+
+cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm12B_emit_copy_short_2b:
+        CMPL BX, $0x00000104
+        JB   repeat_three_repeat_as_copy_encodeBlockAsm12B_emit_copy_short_2b
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm12B
+
+repeat_three_repeat_as_copy_encodeBlockAsm12B_emit_copy_short_2b:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm12B
+
+repeat_two_repeat_as_copy_encodeBlockAsm12B_emit_copy_short_2b:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm12B
+
+repeat_two_offset_repeat_as_copy_encodeBlockAsm12B_emit_copy_short_2b:
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm12B
+
+long_offset_short_repeat_as_copy_encodeBlockAsm12B:
+        MOVB $0xee, (AX)
+        MOVW SI, 1(AX)
+        LEAL -60(BX), BX
+        ADDQ $0x03, AX
+
+        // emitRepeat
+        MOVL BX, DI
+        LEAL -4(BX), BX
+        CMPL DI, $0x08
+        JBE  repeat_two_repeat_as_copy_encodeBlockAsm12B_emit_copy_short
+        CMPL DI, $0x0c
+        JAE  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm12B_emit_copy_short
+        CMPL SI, $0x00000800
+        JB   repeat_two_offset_repeat_as_copy_encodeBlockAsm12B_emit_copy_short
+
+cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm12B_emit_copy_short:
+        CMPL BX, $0x00000104
+        JB   repeat_three_repeat_as_copy_encodeBlockAsm12B_emit_copy_short
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm12B
+
+repeat_three_repeat_as_copy_encodeBlockAsm12B_emit_copy_short:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm12B
+
+repeat_two_repeat_as_copy_encodeBlockAsm12B_emit_copy_short:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm12B
+
+repeat_two_offset_repeat_as_copy_encodeBlockAsm12B_emit_copy_short:
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm12B
+
+two_byte_offset_short_repeat_as_copy_encodeBlockAsm12B:
+        MOVL BX, DI
+        SHLL $0x02, DI
+        CMPL BX, $0x0c
+        JAE  emit_copy_three_repeat_as_copy_encodeBlockAsm12B
+        CMPL SI, $0x00000800
+        JAE  emit_copy_three_repeat_as_copy_encodeBlockAsm12B
+        LEAL -15(DI), DI
+        MOVB SI, 1(AX)
+        SHRL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm12B
+
+emit_copy_three_repeat_as_copy_encodeBlockAsm12B:
+        LEAL -2(DI), DI
+        MOVB DI, (AX)
+        MOVW SI, 1(AX)
+        ADDQ $0x03, AX
+
+repeat_end_emit_encodeBlockAsm12B:
+        MOVL CX, 12(SP)
+        JMP  search_loop_encodeBlockAsm12B
+
+no_repeat_found_encodeBlockAsm12B:
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate_match_encodeBlockAsm12B
+        SHRQ $0x08, SI
+        MOVL 24(SP)(R9*4), BX
+        LEAL 2(CX), R8
+        CMPL (DX)(DI*1), SI
+        JEQ  candidate2_match_encodeBlockAsm12B
+        MOVL R8, 24(SP)(R9*4)
+        SHRQ $0x08, SI
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate3_match_encodeBlockAsm12B
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeBlockAsm12B
+
+candidate3_match_encodeBlockAsm12B:
+        ADDL $0x02, CX
+        JMP  candidate_match_encodeBlockAsm12B
+
+candidate2_match_encodeBlockAsm12B:
+        MOVL R8, 24(SP)(R9*4)
+        INCL CX
+        MOVL DI, BX
+
+candidate_match_encodeBlockAsm12B:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeBlockAsm12B
+
+match_extend_back_loop_encodeBlockAsm12B:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeBlockAsm12B
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeBlockAsm12B
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeBlockAsm12B
+        JMP  match_extend_back_loop_encodeBlockAsm12B
+
+match_extend_back_end_encodeBlockAsm12B:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeBlockAsm12B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeBlockAsm12B:
+        MOVL CX, SI
+        MOVL 12(SP), DI
+        CMPL DI, SI
+        JEQ  emit_literal_done_match_emit_encodeBlockAsm12B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(DI*1), SI
+        SUBL DI, R8
+        LEAL -1(R8), DI
+        CMPL DI, $0x3c
+        JB   one_byte_match_emit_encodeBlockAsm12B
+        CMPL DI, $0x00000100
+        JB   two_bytes_match_emit_encodeBlockAsm12B
+        JB   three_bytes_match_emit_encodeBlockAsm12B
+
+three_bytes_match_emit_encodeBlockAsm12B:
+        MOVB $0xf4, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeBlockAsm12B
+
+two_bytes_match_emit_encodeBlockAsm12B:
+        MOVB $0xf0, (AX)
+        MOVB DI, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DI, $0x40
+        JB   memmove_match_emit_encodeBlockAsm12B
+        JMP  memmove_long_match_emit_encodeBlockAsm12B
+
+one_byte_match_emit_encodeBlockAsm12B:
+        SHLB $0x02, DI
+        MOVB DI, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeBlockAsm12B:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm12B_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm12B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm12B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeBlockAsm12B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeBlockAsm12B_memmove_move_8:
+        MOVQ (SI), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_match_emit_encodeBlockAsm12B
+
+emit_lit_memmove_match_emit_encodeBlockAsm12B_memmove_move_8through16:
+        MOVQ (SI), R9
+        MOVQ -8(SI)(R8*1), SI
+        MOVQ R9, (AX)
+        MOVQ SI, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBlockAsm12B
+
+emit_lit_memmove_match_emit_encodeBlockAsm12B_memmove_move_17through32:
+        MOVOU (SI), X0
+        MOVOU -16(SI)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeBlockAsm12B
+
+emit_lit_memmove_match_emit_encodeBlockAsm12B_memmove_move_33through64:
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeBlockAsm12B:
+        MOVQ DI, AX
+        JMP  emit_literal_done_match_emit_encodeBlockAsm12B
+
+memmove_long_match_emit_encodeBlockAsm12B:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveLong
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVQ  R8, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_match_emit_encodeBlockAsm12Blarge_forward_sse_loop_32
+        LEAQ  -32(SI)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_match_emit_encodeBlockAsm12Blarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_match_emit_encodeBlockAsm12Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeBlockAsm12Blarge_forward_sse_loop_32:
+        MOVOU -32(SI)(R11*1), X4
+        MOVOU -16(SI)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  R8, R11
+        JAE   emit_lit_memmove_long_match_emit_encodeBlockAsm12Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  DI, AX
+
+emit_literal_done_match_emit_encodeBlockAsm12B:
+match_nolit_loop_encodeBlockAsm12B:
+        MOVL CX, SI
+        SUBL BX, SI
+        MOVL SI, 16(SP)
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), SI
+        SUBL CX, SI
+        LEAQ (DX)(CX*1), DI
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R9, R9
+
+matchlen_loopback_16_match_nolit_encodeBlockAsm12B:
+        CMPL SI, $0x10
+        JB   matchlen_match8_match_nolit_encodeBlockAsm12B
+        MOVQ (DI)(R9*1), R8
+        MOVQ 8(DI)(R9*1), R10
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeBlockAsm12B
+        XORQ 8(BX)(R9*1), R10
+        JNZ  matchlen_bsf_16match_nolit_encodeBlockAsm12B
+        LEAL -16(SI), SI
+        LEAL 16(R9), R9
+        JMP  matchlen_loopback_16_match_nolit_encodeBlockAsm12B
+
+matchlen_bsf_16match_nolit_encodeBlockAsm12B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL 8(R9)(R10*1), R9
+        JMP  match_nolit_end_encodeBlockAsm12B
+
+matchlen_match8_match_nolit_encodeBlockAsm12B:
+        CMPL SI, $0x08
+        JB   matchlen_match4_match_nolit_encodeBlockAsm12B
+        MOVQ (DI)(R9*1), R8
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeBlockAsm12B
+        LEAL -8(SI), SI
+        LEAL 8(R9), R9
+        JMP  matchlen_match4_match_nolit_encodeBlockAsm12B
+
+matchlen_bsf_8_match_nolit_encodeBlockAsm12B:
+#ifdef GOAMD64_v3
+        TZCNTQ R8, R8
+
+#else
+        BSFQ R8, R8
+
+#endif
+        SARQ $0x03, R8
+        LEAL (R9)(R8*1), R9
+        JMP  match_nolit_end_encodeBlockAsm12B
+
+matchlen_match4_match_nolit_encodeBlockAsm12B:
+        CMPL SI, $0x04
+        JB   matchlen_match2_match_nolit_encodeBlockAsm12B
+        MOVL (DI)(R9*1), R8
+        CMPL (BX)(R9*1), R8
+        JNE  matchlen_match2_match_nolit_encodeBlockAsm12B
+        LEAL -4(SI), SI
+        LEAL 4(R9), R9
+
+matchlen_match2_match_nolit_encodeBlockAsm12B:
+        CMPL SI, $0x01
+        JE   matchlen_match1_match_nolit_encodeBlockAsm12B
+        JB   match_nolit_end_encodeBlockAsm12B
+        MOVW (DI)(R9*1), R8
+        CMPW (BX)(R9*1), R8
+        JNE  matchlen_match1_match_nolit_encodeBlockAsm12B
+        LEAL 2(R9), R9
+        SUBL $0x02, SI
+        JZ   match_nolit_end_encodeBlockAsm12B
+
+matchlen_match1_match_nolit_encodeBlockAsm12B:
+        MOVB (DI)(R9*1), R8
+        CMPB (BX)(R9*1), R8
+        JNE  match_nolit_end_encodeBlockAsm12B
+        LEAL 1(R9), R9
+
+match_nolit_end_encodeBlockAsm12B:
+        ADDL R9, CX
+        MOVL 16(SP), BX
+        ADDL $0x04, R9
+        MOVL CX, 12(SP)
+
+        // emitCopy
+        CMPL R9, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeBlockAsm12B
+        CMPL BX, $0x00000800
+        JAE  long_offset_short_match_nolit_encodeBlockAsm12B
+        MOVL $0x00000001, SI
+        LEAL 16(SI), SI
+        MOVB BL, 1(AX)
+        SHRL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, R9
+
+        // emitRepeat
+        LEAL -4(R9), R9
+        JMP  cant_repeat_two_offset_match_nolit_encodeBlockAsm12B_emit_copy_short_2b
+        MOVL R9, SI
+        LEAL -4(R9), R9
+        CMPL SI, $0x08
+        JBE  repeat_two_match_nolit_encodeBlockAsm12B_emit_copy_short_2b
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBlockAsm12B_emit_copy_short_2b
+        CMPL BX, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBlockAsm12B_emit_copy_short_2b
+
+cant_repeat_two_offset_match_nolit_encodeBlockAsm12B_emit_copy_short_2b:
+        CMPL R9, $0x00000104
+        JB   repeat_three_match_nolit_encodeBlockAsm12B_emit_copy_short_2b
+        LEAL -256(R9), R9
+        MOVW $0x0019, (AX)
+        MOVW R9, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm12B
+
+repeat_three_match_nolit_encodeBlockAsm12B_emit_copy_short_2b:
+        LEAL -4(R9), R9
+        MOVW $0x0015, (AX)
+        MOVB R9, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm12B
+
+repeat_two_match_nolit_encodeBlockAsm12B_emit_copy_short_2b:
+        SHLL $0x02, R9
+        ORL  $0x01, R9
+        MOVW R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm12B
+
+repeat_two_offset_match_nolit_encodeBlockAsm12B_emit_copy_short_2b:
+        XORQ SI, SI
+        LEAL 1(SI)(R9*4), R9
+        MOVB BL, 1(AX)
+        SARL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, R9
+        MOVB R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm12B
+
+long_offset_short_match_nolit_encodeBlockAsm12B:
+        MOVB $0xee, (AX)
+        MOVW BX, 1(AX)
+        LEAL -60(R9), R9
+        ADDQ $0x03, AX
+
+        // emitRepeat
+        MOVL R9, SI
+        LEAL -4(R9), R9
+        CMPL SI, $0x08
+        JBE  repeat_two_match_nolit_encodeBlockAsm12B_emit_copy_short
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBlockAsm12B_emit_copy_short
+        CMPL BX, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBlockAsm12B_emit_copy_short
+
+cant_repeat_two_offset_match_nolit_encodeBlockAsm12B_emit_copy_short:
+        CMPL R9, $0x00000104
+        JB   repeat_three_match_nolit_encodeBlockAsm12B_emit_copy_short
+        LEAL -256(R9), R9
+        MOVW $0x0019, (AX)
+        MOVW R9, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm12B
+
+repeat_three_match_nolit_encodeBlockAsm12B_emit_copy_short:
+        LEAL -4(R9), R9
+        MOVW $0x0015, (AX)
+        MOVB R9, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm12B
+
+repeat_two_match_nolit_encodeBlockAsm12B_emit_copy_short:
+        SHLL $0x02, R9
+        ORL  $0x01, R9
+        MOVW R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm12B
+
+repeat_two_offset_match_nolit_encodeBlockAsm12B_emit_copy_short:
+        XORQ SI, SI
+        LEAL 1(SI)(R9*4), R9
+        MOVB BL, 1(AX)
+        SARL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, R9
+        MOVB R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm12B
+
+two_byte_offset_short_match_nolit_encodeBlockAsm12B:
+        MOVL R9, SI
+        SHLL $0x02, SI
+        CMPL R9, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeBlockAsm12B
+        CMPL BX, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeBlockAsm12B
+        LEAL -15(SI), SI
+        MOVB BL, 1(AX)
+        SHRL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm12B
+
+emit_copy_three_match_nolit_encodeBlockAsm12B:
+        LEAL -2(SI), SI
+        MOVB SI, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeBlockAsm12B:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeBlockAsm12B
+        MOVQ -2(DX)(CX*1), SI
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeBlockAsm12B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeBlockAsm12B:
+        MOVQ  $0x000000cf1bbcdcbb, R8
+        MOVQ  SI, DI
+        SHRQ  $0x10, SI
+        MOVQ  SI, BX
+        SHLQ  $0x18, DI
+        IMULQ R8, DI
+        SHRQ  $0x34, DI
+        SHLQ  $0x18, BX
+        IMULQ R8, BX
+        SHRQ  $0x34, BX
+        LEAL  -2(CX), R8
+        LEAQ  24(SP)(BX*4), R9
+        MOVL  (R9), BX
+        MOVL  R8, 24(SP)(DI*4)
+        MOVL  CX, (R9)
+        CMPL  (DX)(BX*1), SI
+        JEQ   match_nolit_loop_encodeBlockAsm12B
+        INCL  CX
+        JMP   search_loop_encodeBlockAsm12B
+
+emit_remainder_encodeBlockAsm12B:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeBlockAsm12B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeBlockAsm12B:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeBlockAsm12B
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeBlockAsm12B
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeBlockAsm12B
+        JB   three_bytes_emit_remainder_encodeBlockAsm12B
+
+three_bytes_emit_remainder_encodeBlockAsm12B:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeBlockAsm12B
+
+two_bytes_emit_remainder_encodeBlockAsm12B:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeBlockAsm12B
+        JMP  memmove_long_emit_remainder_encodeBlockAsm12B
+
+one_byte_emit_remainder_encodeBlockAsm12B:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeBlockAsm12B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeBlockAsm12B_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeBlockAsm12B_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeBlockAsm12B_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeBlockAsm12B_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeBlockAsm12B_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeBlockAsm12B_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm12B_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm12B_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm12B_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm12B_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm12B_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm12B_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeBlockAsm12B:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeBlockAsm12B
+
+memmove_long_emit_remainder_encodeBlockAsm12B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeBlockAsm12Blarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeBlockAsm12Blarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeBlockAsm12Blarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeBlockAsm12Blarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeBlockAsm12Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeBlockAsm12B:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeBlockAsm10B(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeBlockAsm10B(SB), $4120-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000020, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeBlockAsm10B:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeBlockAsm10B
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  CX, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeBlockAsm10B:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x05, BX
+        LEAL  4(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeBlockAsm10B
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x9e3779b1, R8
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHRQ  $0x08, R10
+        SHLQ  $0x20, R9
+        IMULQ R8, R9
+        SHRQ  $0x36, R9
+        SHLQ  $0x20, R10
+        IMULQ R8, R10
+        SHRQ  $0x36, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  24(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        LEAL  1(CX), R9
+        MOVL  R9, 24(SP)(R10*4)
+        MOVQ  SI, R9
+        SHRQ  $0x10, R9
+        SHLQ  $0x20, R9
+        IMULQ R8, R9
+        SHRQ  $0x36, R9
+        MOVL  CX, R8
+        SUBL  16(SP), R8
+        MOVL  1(DX)(R8*1), R10
+        MOVQ  SI, R8
+        SHRQ  $0x08, R8
+        CMPL  R8, R10
+        JNE   no_repeat_found_encodeBlockAsm10B
+        LEAL  1(CX), SI
+        MOVL  12(SP), DI
+        MOVL  SI, BX
+        SUBL  16(SP), BX
+        JZ    repeat_extend_back_end_encodeBlockAsm10B
+
+repeat_extend_back_loop_encodeBlockAsm10B:
+        CMPL SI, DI
+        JBE  repeat_extend_back_end_encodeBlockAsm10B
+        MOVB -1(DX)(BX*1), R8
+        MOVB -1(DX)(SI*1), R9
+        CMPB R8, R9
+        JNE  repeat_extend_back_end_encodeBlockAsm10B
+        LEAL -1(SI), SI
+        DECL BX
+        JNZ  repeat_extend_back_loop_encodeBlockAsm10B
+
+repeat_extend_back_end_encodeBlockAsm10B:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_repeat_emit_encodeBlockAsm10B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_repeat_emit_encodeBlockAsm10B
+        CMPL BX, $0x00000100
+        JB   two_bytes_repeat_emit_encodeBlockAsm10B
+        JB   three_bytes_repeat_emit_encodeBlockAsm10B
+
+three_bytes_repeat_emit_encodeBlockAsm10B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_repeat_emit_encodeBlockAsm10B
+
+two_bytes_repeat_emit_encodeBlockAsm10B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_repeat_emit_encodeBlockAsm10B
+        JMP  memmove_long_repeat_emit_encodeBlockAsm10B
+
+one_byte_repeat_emit_encodeBlockAsm10B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_repeat_emit_encodeBlockAsm10B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm10B_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm10B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm10B_memmove_move_17through32
+        JMP  emit_lit_memmove_repeat_emit_encodeBlockAsm10B_memmove_move_33through64
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm10B_memmove_move_8:
+        MOVQ (R9), R10
+        MOVQ R10, (AX)
+        JMP  memmove_end_copy_repeat_emit_encodeBlockAsm10B
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm10B_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_repeat_emit_encodeBlockAsm10B
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm10B_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_repeat_emit_encodeBlockAsm10B
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm10B_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_repeat_emit_encodeBlockAsm10B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_repeat_emit_encodeBlockAsm10B
+
+memmove_long_repeat_emit_encodeBlockAsm10B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R11
+        SHRQ  $0x05, R11
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R12
+        SUBQ  R10, R12
+        DECQ  R11
+        JA    emit_lit_memmove_long_repeat_emit_encodeBlockAsm10Blarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R12*1), R10
+        LEAQ  -32(AX)(R12*1), R13
+
+emit_lit_memmove_long_repeat_emit_encodeBlockAsm10Blarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R13)
+        MOVOA X5, 16(R13)
+        ADDQ  $0x20, R13
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R12
+        DECQ  R11
+        JNA   emit_lit_memmove_long_repeat_emit_encodeBlockAsm10Blarge_big_loop_back
+
+emit_lit_memmove_long_repeat_emit_encodeBlockAsm10Blarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R12*1), X4
+        MOVOU -16(R9)(R12*1), X5
+        MOVOA X4, -32(AX)(R12*1)
+        MOVOA X5, -16(AX)(R12*1)
+        ADDQ  $0x20, R12
+        CMPQ  R8, R12
+        JAE   emit_lit_memmove_long_repeat_emit_encodeBlockAsm10Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_repeat_emit_encodeBlockAsm10B:
+        ADDL $0x05, CX
+        MOVL CX, BX
+        SUBL 16(SP), BX
+        MOVQ src_len+32(FP), R8
+        SUBL CX, R8
+        LEAQ (DX)(CX*1), R9
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_repeat_extend_encodeBlockAsm10B:
+        CMPL R8, $0x10
+        JB   matchlen_match8_repeat_extend_encodeBlockAsm10B
+        MOVQ (R9)(R11*1), R10
+        MOVQ 8(R9)(R11*1), R12
+        XORQ (BX)(R11*1), R10
+        JNZ  matchlen_bsf_8_repeat_extend_encodeBlockAsm10B
+        XORQ 8(BX)(R11*1), R12
+        JNZ  matchlen_bsf_16repeat_extend_encodeBlockAsm10B
+        LEAL -16(R8), R8
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_repeat_extend_encodeBlockAsm10B
+
+matchlen_bsf_16repeat_extend_encodeBlockAsm10B:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  repeat_extend_forward_end_encodeBlockAsm10B
+
+matchlen_match8_repeat_extend_encodeBlockAsm10B:
+        CMPL R8, $0x08
+        JB   matchlen_match4_repeat_extend_encodeBlockAsm10B
+        MOVQ (R9)(R11*1), R10
+        XORQ (BX)(R11*1), R10
+        JNZ  matchlen_bsf_8_repeat_extend_encodeBlockAsm10B
+        LEAL -8(R8), R8
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_repeat_extend_encodeBlockAsm10B
+
+matchlen_bsf_8_repeat_extend_encodeBlockAsm10B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  repeat_extend_forward_end_encodeBlockAsm10B
+
+matchlen_match4_repeat_extend_encodeBlockAsm10B:
+        CMPL R8, $0x04
+        JB   matchlen_match2_repeat_extend_encodeBlockAsm10B
+        MOVL (R9)(R11*1), R10
+        CMPL (BX)(R11*1), R10
+        JNE  matchlen_match2_repeat_extend_encodeBlockAsm10B
+        LEAL -4(R8), R8
+        LEAL 4(R11), R11
+
+matchlen_match2_repeat_extend_encodeBlockAsm10B:
+        CMPL R8, $0x01
+        JE   matchlen_match1_repeat_extend_encodeBlockAsm10B
+        JB   repeat_extend_forward_end_encodeBlockAsm10B
+        MOVW (R9)(R11*1), R10
+        CMPW (BX)(R11*1), R10
+        JNE  matchlen_match1_repeat_extend_encodeBlockAsm10B
+        LEAL 2(R11), R11
+        SUBL $0x02, R8
+        JZ   repeat_extend_forward_end_encodeBlockAsm10B
+
+matchlen_match1_repeat_extend_encodeBlockAsm10B:
+        MOVB (R9)(R11*1), R10
+        CMPB (BX)(R11*1), R10
+        JNE  repeat_extend_forward_end_encodeBlockAsm10B
+        LEAL 1(R11), R11
+
+repeat_extend_forward_end_encodeBlockAsm10B:
+        ADDL  R11, CX
+        MOVL  CX, BX
+        SUBL  SI, BX
+        MOVL  16(SP), SI
+        TESTL DI, DI
+        JZ    repeat_as_copy_encodeBlockAsm10B
+
+        // emitRepeat
+        MOVL BX, DI
+        LEAL -4(BX), BX
+        CMPL DI, $0x08
+        JBE  repeat_two_match_repeat_encodeBlockAsm10B
+        CMPL DI, $0x0c
+        JAE  cant_repeat_two_offset_match_repeat_encodeBlockAsm10B
+        CMPL SI, $0x00000800
+        JB   repeat_two_offset_match_repeat_encodeBlockAsm10B
+
+cant_repeat_two_offset_match_repeat_encodeBlockAsm10B:
+        CMPL BX, $0x00000104
+        JB   repeat_three_match_repeat_encodeBlockAsm10B
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm10B
+
+repeat_three_match_repeat_encodeBlockAsm10B:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm10B
+
+repeat_two_match_repeat_encodeBlockAsm10B:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm10B
+
+repeat_two_offset_match_repeat_encodeBlockAsm10B:
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm10B
+
+repeat_as_copy_encodeBlockAsm10B:
+        // emitCopy
+        CMPL BX, $0x40
+        JBE  two_byte_offset_short_repeat_as_copy_encodeBlockAsm10B
+        CMPL SI, $0x00000800
+        JAE  long_offset_short_repeat_as_copy_encodeBlockAsm10B
+        MOVL $0x00000001, DI
+        LEAL 16(DI), DI
+        MOVB SI, 1(AX)
+        SHRL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, BX
+
+        // emitRepeat
+        LEAL -4(BX), BX
+        JMP  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm10B_emit_copy_short_2b
+        MOVL BX, DI
+        LEAL -4(BX), BX
+        CMPL DI, $0x08
+        JBE  repeat_two_repeat_as_copy_encodeBlockAsm10B_emit_copy_short_2b
+        CMPL DI, $0x0c
+        JAE  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm10B_emit_copy_short_2b
+        CMPL SI, $0x00000800
+        JB   repeat_two_offset_repeat_as_copy_encodeBlockAsm10B_emit_copy_short_2b
+
+cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm10B_emit_copy_short_2b:
+        CMPL BX, $0x00000104
+        JB   repeat_three_repeat_as_copy_encodeBlockAsm10B_emit_copy_short_2b
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm10B
+
+repeat_three_repeat_as_copy_encodeBlockAsm10B_emit_copy_short_2b:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm10B
+
+repeat_two_repeat_as_copy_encodeBlockAsm10B_emit_copy_short_2b:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm10B
+
+repeat_two_offset_repeat_as_copy_encodeBlockAsm10B_emit_copy_short_2b:
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm10B
+
+long_offset_short_repeat_as_copy_encodeBlockAsm10B:
+        MOVB $0xee, (AX)
+        MOVW SI, 1(AX)
+        LEAL -60(BX), BX
+        ADDQ $0x03, AX
+
+        // emitRepeat
+        MOVL BX, DI
+        LEAL -4(BX), BX
+        CMPL DI, $0x08
+        JBE  repeat_two_repeat_as_copy_encodeBlockAsm10B_emit_copy_short
+        CMPL DI, $0x0c
+        JAE  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm10B_emit_copy_short
+        CMPL SI, $0x00000800
+        JB   repeat_two_offset_repeat_as_copy_encodeBlockAsm10B_emit_copy_short
+
+cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm10B_emit_copy_short:
+        CMPL BX, $0x00000104
+        JB   repeat_three_repeat_as_copy_encodeBlockAsm10B_emit_copy_short
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm10B
+
+repeat_three_repeat_as_copy_encodeBlockAsm10B_emit_copy_short:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm10B
+
+repeat_two_repeat_as_copy_encodeBlockAsm10B_emit_copy_short:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm10B
+
+repeat_two_offset_repeat_as_copy_encodeBlockAsm10B_emit_copy_short:
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm10B
+
+two_byte_offset_short_repeat_as_copy_encodeBlockAsm10B:
+        MOVL BX, DI
+        SHLL $0x02, DI
+        CMPL BX, $0x0c
+        JAE  emit_copy_three_repeat_as_copy_encodeBlockAsm10B
+        CMPL SI, $0x00000800
+        JAE  emit_copy_three_repeat_as_copy_encodeBlockAsm10B
+        LEAL -15(DI), DI
+        MOVB SI, 1(AX)
+        SHRL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm10B
+
+emit_copy_three_repeat_as_copy_encodeBlockAsm10B:
+        LEAL -2(DI), DI
+        MOVB DI, (AX)
+        MOVW SI, 1(AX)
+        ADDQ $0x03, AX
+
+repeat_end_emit_encodeBlockAsm10B:
+        MOVL CX, 12(SP)
+        JMP  search_loop_encodeBlockAsm10B
+
+no_repeat_found_encodeBlockAsm10B:
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate_match_encodeBlockAsm10B
+        SHRQ $0x08, SI
+        MOVL 24(SP)(R9*4), BX
+        LEAL 2(CX), R8
+        CMPL (DX)(DI*1), SI
+        JEQ  candidate2_match_encodeBlockAsm10B
+        MOVL R8, 24(SP)(R9*4)
+        SHRQ $0x08, SI
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate3_match_encodeBlockAsm10B
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeBlockAsm10B
+
+candidate3_match_encodeBlockAsm10B:
+        ADDL $0x02, CX
+        JMP  candidate_match_encodeBlockAsm10B
+
+candidate2_match_encodeBlockAsm10B:
+        MOVL R8, 24(SP)(R9*4)
+        INCL CX
+        MOVL DI, BX
+
+candidate_match_encodeBlockAsm10B:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeBlockAsm10B
+
+match_extend_back_loop_encodeBlockAsm10B:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeBlockAsm10B
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeBlockAsm10B
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeBlockAsm10B
+        JMP  match_extend_back_loop_encodeBlockAsm10B
+
+match_extend_back_end_encodeBlockAsm10B:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeBlockAsm10B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeBlockAsm10B:
+        MOVL CX, SI
+        MOVL 12(SP), DI
+        CMPL DI, SI
+        JEQ  emit_literal_done_match_emit_encodeBlockAsm10B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(DI*1), SI
+        SUBL DI, R8
+        LEAL -1(R8), DI
+        CMPL DI, $0x3c
+        JB   one_byte_match_emit_encodeBlockAsm10B
+        CMPL DI, $0x00000100
+        JB   two_bytes_match_emit_encodeBlockAsm10B
+        JB   three_bytes_match_emit_encodeBlockAsm10B
+
+three_bytes_match_emit_encodeBlockAsm10B:
+        MOVB $0xf4, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeBlockAsm10B
+
+two_bytes_match_emit_encodeBlockAsm10B:
+        MOVB $0xf0, (AX)
+        MOVB DI, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DI, $0x40
+        JB   memmove_match_emit_encodeBlockAsm10B
+        JMP  memmove_long_match_emit_encodeBlockAsm10B
+
+one_byte_match_emit_encodeBlockAsm10B:
+        SHLB $0x02, DI
+        MOVB DI, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeBlockAsm10B:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm10B_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm10B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm10B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeBlockAsm10B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeBlockAsm10B_memmove_move_8:
+        MOVQ (SI), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_match_emit_encodeBlockAsm10B
+
+emit_lit_memmove_match_emit_encodeBlockAsm10B_memmove_move_8through16:
+        MOVQ (SI), R9
+        MOVQ -8(SI)(R8*1), SI
+        MOVQ R9, (AX)
+        MOVQ SI, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBlockAsm10B
+
+emit_lit_memmove_match_emit_encodeBlockAsm10B_memmove_move_17through32:
+        MOVOU (SI), X0
+        MOVOU -16(SI)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeBlockAsm10B
+
+emit_lit_memmove_match_emit_encodeBlockAsm10B_memmove_move_33through64:
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeBlockAsm10B:
+        MOVQ DI, AX
+        JMP  emit_literal_done_match_emit_encodeBlockAsm10B
+
+memmove_long_match_emit_encodeBlockAsm10B:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveLong
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVQ  R8, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_match_emit_encodeBlockAsm10Blarge_forward_sse_loop_32
+        LEAQ  -32(SI)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_match_emit_encodeBlockAsm10Blarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_match_emit_encodeBlockAsm10Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeBlockAsm10Blarge_forward_sse_loop_32:
+        MOVOU -32(SI)(R11*1), X4
+        MOVOU -16(SI)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  R8, R11
+        JAE   emit_lit_memmove_long_match_emit_encodeBlockAsm10Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  DI, AX
+
+emit_literal_done_match_emit_encodeBlockAsm10B:
+match_nolit_loop_encodeBlockAsm10B:
+        MOVL CX, SI
+        SUBL BX, SI
+        MOVL SI, 16(SP)
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), SI
+        SUBL CX, SI
+        LEAQ (DX)(CX*1), DI
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R9, R9
+
+matchlen_loopback_16_match_nolit_encodeBlockAsm10B:
+        CMPL SI, $0x10
+        JB   matchlen_match8_match_nolit_encodeBlockAsm10B
+        MOVQ (DI)(R9*1), R8
+        MOVQ 8(DI)(R9*1), R10
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeBlockAsm10B
+        XORQ 8(BX)(R9*1), R10
+        JNZ  matchlen_bsf_16match_nolit_encodeBlockAsm10B
+        LEAL -16(SI), SI
+        LEAL 16(R9), R9
+        JMP  matchlen_loopback_16_match_nolit_encodeBlockAsm10B
+
+matchlen_bsf_16match_nolit_encodeBlockAsm10B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL 8(R9)(R10*1), R9
+        JMP  match_nolit_end_encodeBlockAsm10B
+
+matchlen_match8_match_nolit_encodeBlockAsm10B:
+        CMPL SI, $0x08
+        JB   matchlen_match4_match_nolit_encodeBlockAsm10B
+        MOVQ (DI)(R9*1), R8
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeBlockAsm10B
+        LEAL -8(SI), SI
+        LEAL 8(R9), R9
+        JMP  matchlen_match4_match_nolit_encodeBlockAsm10B
+
+matchlen_bsf_8_match_nolit_encodeBlockAsm10B:
+#ifdef GOAMD64_v3
+        TZCNTQ R8, R8
+
+#else
+        BSFQ R8, R8
+
+#endif
+        SARQ $0x03, R8
+        LEAL (R9)(R8*1), R9
+        JMP  match_nolit_end_encodeBlockAsm10B
+
+matchlen_match4_match_nolit_encodeBlockAsm10B:
+        CMPL SI, $0x04
+        JB   matchlen_match2_match_nolit_encodeBlockAsm10B
+        MOVL (DI)(R9*1), R8
+        CMPL (BX)(R9*1), R8
+        JNE  matchlen_match2_match_nolit_encodeBlockAsm10B
+        LEAL -4(SI), SI
+        LEAL 4(R9), R9
+
+matchlen_match2_match_nolit_encodeBlockAsm10B:
+        CMPL SI, $0x01
+        JE   matchlen_match1_match_nolit_encodeBlockAsm10B
+        JB   match_nolit_end_encodeBlockAsm10B
+        MOVW (DI)(R9*1), R8
+        CMPW (BX)(R9*1), R8
+        JNE  matchlen_match1_match_nolit_encodeBlockAsm10B
+        LEAL 2(R9), R9
+        SUBL $0x02, SI
+        JZ   match_nolit_end_encodeBlockAsm10B
+
+matchlen_match1_match_nolit_encodeBlockAsm10B:
+        MOVB (DI)(R9*1), R8
+        CMPB (BX)(R9*1), R8
+        JNE  match_nolit_end_encodeBlockAsm10B
+        LEAL 1(R9), R9
+
+match_nolit_end_encodeBlockAsm10B:
+        ADDL R9, CX
+        MOVL 16(SP), BX
+        ADDL $0x04, R9
+        MOVL CX, 12(SP)
+
+        // emitCopy
+        CMPL R9, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeBlockAsm10B
+        CMPL BX, $0x00000800
+        JAE  long_offset_short_match_nolit_encodeBlockAsm10B
+        MOVL $0x00000001, SI
+        LEAL 16(SI), SI
+        MOVB BL, 1(AX)
+        SHRL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, R9
+
+        // emitRepeat
+        LEAL -4(R9), R9
+        JMP  cant_repeat_two_offset_match_nolit_encodeBlockAsm10B_emit_copy_short_2b
+        MOVL R9, SI
+        LEAL -4(R9), R9
+        CMPL SI, $0x08
+        JBE  repeat_two_match_nolit_encodeBlockAsm10B_emit_copy_short_2b
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBlockAsm10B_emit_copy_short_2b
+        CMPL BX, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBlockAsm10B_emit_copy_short_2b
+
+cant_repeat_two_offset_match_nolit_encodeBlockAsm10B_emit_copy_short_2b:
+        CMPL R9, $0x00000104
+        JB   repeat_three_match_nolit_encodeBlockAsm10B_emit_copy_short_2b
+        LEAL -256(R9), R9
+        MOVW $0x0019, (AX)
+        MOVW R9, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm10B
+
+repeat_three_match_nolit_encodeBlockAsm10B_emit_copy_short_2b:
+        LEAL -4(R9), R9
+        MOVW $0x0015, (AX)
+        MOVB R9, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm10B
+
+repeat_two_match_nolit_encodeBlockAsm10B_emit_copy_short_2b:
+        SHLL $0x02, R9
+        ORL  $0x01, R9
+        MOVW R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm10B
+
+repeat_two_offset_match_nolit_encodeBlockAsm10B_emit_copy_short_2b:
+        XORQ SI, SI
+        LEAL 1(SI)(R9*4), R9
+        MOVB BL, 1(AX)
+        SARL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, R9
+        MOVB R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm10B
+
+long_offset_short_match_nolit_encodeBlockAsm10B:
+        MOVB $0xee, (AX)
+        MOVW BX, 1(AX)
+        LEAL -60(R9), R9
+        ADDQ $0x03, AX
+
+        // emitRepeat
+        MOVL R9, SI
+        LEAL -4(R9), R9
+        CMPL SI, $0x08
+        JBE  repeat_two_match_nolit_encodeBlockAsm10B_emit_copy_short
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBlockAsm10B_emit_copy_short
+        CMPL BX, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBlockAsm10B_emit_copy_short
+
+cant_repeat_two_offset_match_nolit_encodeBlockAsm10B_emit_copy_short:
+        CMPL R9, $0x00000104
+        JB   repeat_three_match_nolit_encodeBlockAsm10B_emit_copy_short
+        LEAL -256(R9), R9
+        MOVW $0x0019, (AX)
+        MOVW R9, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm10B
+
+repeat_three_match_nolit_encodeBlockAsm10B_emit_copy_short:
+        LEAL -4(R9), R9
+        MOVW $0x0015, (AX)
+        MOVB R9, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm10B
+
+repeat_two_match_nolit_encodeBlockAsm10B_emit_copy_short:
+        SHLL $0x02, R9
+        ORL  $0x01, R9
+        MOVW R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm10B
+
+repeat_two_offset_match_nolit_encodeBlockAsm10B_emit_copy_short:
+        XORQ SI, SI
+        LEAL 1(SI)(R9*4), R9
+        MOVB BL, 1(AX)
+        SARL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, R9
+        MOVB R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm10B
+
+two_byte_offset_short_match_nolit_encodeBlockAsm10B:
+        MOVL R9, SI
+        SHLL $0x02, SI
+        CMPL R9, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeBlockAsm10B
+        CMPL BX, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeBlockAsm10B
+        LEAL -15(SI), SI
+        MOVB BL, 1(AX)
+        SHRL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm10B
+
+emit_copy_three_match_nolit_encodeBlockAsm10B:
+        LEAL -2(SI), SI
+        MOVB SI, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeBlockAsm10B:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeBlockAsm10B
+        MOVQ -2(DX)(CX*1), SI
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeBlockAsm10B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeBlockAsm10B:
+        MOVQ  $0x9e3779b1, R8
+        MOVQ  SI, DI
+        SHRQ  $0x10, SI
+        MOVQ  SI, BX
+        SHLQ  $0x20, DI
+        IMULQ R8, DI
+        SHRQ  $0x36, DI
+        SHLQ  $0x20, BX
+        IMULQ R8, BX
+        SHRQ  $0x36, BX
+        LEAL  -2(CX), R8
+        LEAQ  24(SP)(BX*4), R9
+        MOVL  (R9), BX
+        MOVL  R8, 24(SP)(DI*4)
+        MOVL  CX, (R9)
+        CMPL  (DX)(BX*1), SI
+        JEQ   match_nolit_loop_encodeBlockAsm10B
+        INCL  CX
+        JMP   search_loop_encodeBlockAsm10B
+
+emit_remainder_encodeBlockAsm10B:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeBlockAsm10B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeBlockAsm10B:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeBlockAsm10B
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeBlockAsm10B
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeBlockAsm10B
+        JB   three_bytes_emit_remainder_encodeBlockAsm10B
+
+three_bytes_emit_remainder_encodeBlockAsm10B:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeBlockAsm10B
+
+two_bytes_emit_remainder_encodeBlockAsm10B:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeBlockAsm10B
+        JMP  memmove_long_emit_remainder_encodeBlockAsm10B
+
+one_byte_emit_remainder_encodeBlockAsm10B:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeBlockAsm10B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeBlockAsm10B_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeBlockAsm10B_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeBlockAsm10B_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeBlockAsm10B_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeBlockAsm10B_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeBlockAsm10B_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm10B_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm10B_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm10B_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm10B_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm10B_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm10B_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeBlockAsm10B:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeBlockAsm10B
+
+memmove_long_emit_remainder_encodeBlockAsm10B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeBlockAsm10Blarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeBlockAsm10Blarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeBlockAsm10Blarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeBlockAsm10Blarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeBlockAsm10Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeBlockAsm10B:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeBlockAsm8B(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeBlockAsm8B(SB), $1048-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000008, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeBlockAsm8B:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeBlockAsm8B
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  CX, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeBlockAsm8B:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x04, BX
+        LEAL  4(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeBlockAsm8B
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x9e3779b1, R8
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHRQ  $0x08, R10
+        SHLQ  $0x20, R9
+        IMULQ R8, R9
+        SHRQ  $0x38, R9
+        SHLQ  $0x20, R10
+        IMULQ R8, R10
+        SHRQ  $0x38, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  24(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        LEAL  1(CX), R9
+        MOVL  R9, 24(SP)(R10*4)
+        MOVQ  SI, R9
+        SHRQ  $0x10, R9
+        SHLQ  $0x20, R9
+        IMULQ R8, R9
+        SHRQ  $0x38, R9
+        MOVL  CX, R8
+        SUBL  16(SP), R8
+        MOVL  1(DX)(R8*1), R10
+        MOVQ  SI, R8
+        SHRQ  $0x08, R8
+        CMPL  R8, R10
+        JNE   no_repeat_found_encodeBlockAsm8B
+        LEAL  1(CX), SI
+        MOVL  12(SP), DI
+        MOVL  SI, BX
+        SUBL  16(SP), BX
+        JZ    repeat_extend_back_end_encodeBlockAsm8B
+
+repeat_extend_back_loop_encodeBlockAsm8B:
+        CMPL SI, DI
+        JBE  repeat_extend_back_end_encodeBlockAsm8B
+        MOVB -1(DX)(BX*1), R8
+        MOVB -1(DX)(SI*1), R9
+        CMPB R8, R9
+        JNE  repeat_extend_back_end_encodeBlockAsm8B
+        LEAL -1(SI), SI
+        DECL BX
+        JNZ  repeat_extend_back_loop_encodeBlockAsm8B
+
+repeat_extend_back_end_encodeBlockAsm8B:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_repeat_emit_encodeBlockAsm8B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_repeat_emit_encodeBlockAsm8B
+        CMPL BX, $0x00000100
+        JB   two_bytes_repeat_emit_encodeBlockAsm8B
+        JB   three_bytes_repeat_emit_encodeBlockAsm8B
+
+three_bytes_repeat_emit_encodeBlockAsm8B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_repeat_emit_encodeBlockAsm8B
+
+two_bytes_repeat_emit_encodeBlockAsm8B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_repeat_emit_encodeBlockAsm8B
+        JMP  memmove_long_repeat_emit_encodeBlockAsm8B
+
+one_byte_repeat_emit_encodeBlockAsm8B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_repeat_emit_encodeBlockAsm8B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm8B_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm8B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_repeat_emit_encodeBlockAsm8B_memmove_move_17through32
+        JMP  emit_lit_memmove_repeat_emit_encodeBlockAsm8B_memmove_move_33through64
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm8B_memmove_move_8:
+        MOVQ (R9), R10
+        MOVQ R10, (AX)
+        JMP  memmove_end_copy_repeat_emit_encodeBlockAsm8B
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm8B_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_repeat_emit_encodeBlockAsm8B
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm8B_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_repeat_emit_encodeBlockAsm8B
+
+emit_lit_memmove_repeat_emit_encodeBlockAsm8B_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_repeat_emit_encodeBlockAsm8B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_repeat_emit_encodeBlockAsm8B
+
+memmove_long_repeat_emit_encodeBlockAsm8B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R11
+        SHRQ  $0x05, R11
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R12
+        SUBQ  R10, R12
+        DECQ  R11
+        JA    emit_lit_memmove_long_repeat_emit_encodeBlockAsm8Blarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R12*1), R10
+        LEAQ  -32(AX)(R12*1), R13
+
+emit_lit_memmove_long_repeat_emit_encodeBlockAsm8Blarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R13)
+        MOVOA X5, 16(R13)
+        ADDQ  $0x20, R13
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R12
+        DECQ  R11
+        JNA   emit_lit_memmove_long_repeat_emit_encodeBlockAsm8Blarge_big_loop_back
+
+emit_lit_memmove_long_repeat_emit_encodeBlockAsm8Blarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R12*1), X4
+        MOVOU -16(R9)(R12*1), X5
+        MOVOA X4, -32(AX)(R12*1)
+        MOVOA X5, -16(AX)(R12*1)
+        ADDQ  $0x20, R12
+        CMPQ  R8, R12
+        JAE   emit_lit_memmove_long_repeat_emit_encodeBlockAsm8Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_repeat_emit_encodeBlockAsm8B:
+        ADDL $0x05, CX
+        MOVL CX, BX
+        SUBL 16(SP), BX
+        MOVQ src_len+32(FP), R8
+        SUBL CX, R8
+        LEAQ (DX)(CX*1), R9
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_repeat_extend_encodeBlockAsm8B:
+        CMPL R8, $0x10
+        JB   matchlen_match8_repeat_extend_encodeBlockAsm8B
+        MOVQ (R9)(R11*1), R10
+        MOVQ 8(R9)(R11*1), R12
+        XORQ (BX)(R11*1), R10
+        JNZ  matchlen_bsf_8_repeat_extend_encodeBlockAsm8B
+        XORQ 8(BX)(R11*1), R12
+        JNZ  matchlen_bsf_16repeat_extend_encodeBlockAsm8B
+        LEAL -16(R8), R8
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_repeat_extend_encodeBlockAsm8B
+
+matchlen_bsf_16repeat_extend_encodeBlockAsm8B:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  repeat_extend_forward_end_encodeBlockAsm8B
+
+matchlen_match8_repeat_extend_encodeBlockAsm8B:
+        CMPL R8, $0x08
+        JB   matchlen_match4_repeat_extend_encodeBlockAsm8B
+        MOVQ (R9)(R11*1), R10
+        XORQ (BX)(R11*1), R10
+        JNZ  matchlen_bsf_8_repeat_extend_encodeBlockAsm8B
+        LEAL -8(R8), R8
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_repeat_extend_encodeBlockAsm8B
+
+matchlen_bsf_8_repeat_extend_encodeBlockAsm8B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  repeat_extend_forward_end_encodeBlockAsm8B
+
+matchlen_match4_repeat_extend_encodeBlockAsm8B:
+        CMPL R8, $0x04
+        JB   matchlen_match2_repeat_extend_encodeBlockAsm8B
+        MOVL (R9)(R11*1), R10
+        CMPL (BX)(R11*1), R10
+        JNE  matchlen_match2_repeat_extend_encodeBlockAsm8B
+        LEAL -4(R8), R8
+        LEAL 4(R11), R11
+
+matchlen_match2_repeat_extend_encodeBlockAsm8B:
+        CMPL R8, $0x01
+        JE   matchlen_match1_repeat_extend_encodeBlockAsm8B
+        JB   repeat_extend_forward_end_encodeBlockAsm8B
+        MOVW (R9)(R11*1), R10
+        CMPW (BX)(R11*1), R10
+        JNE  matchlen_match1_repeat_extend_encodeBlockAsm8B
+        LEAL 2(R11), R11
+        SUBL $0x02, R8
+        JZ   repeat_extend_forward_end_encodeBlockAsm8B
+
+matchlen_match1_repeat_extend_encodeBlockAsm8B:
+        MOVB (R9)(R11*1), R10
+        CMPB (BX)(R11*1), R10
+        JNE  repeat_extend_forward_end_encodeBlockAsm8B
+        LEAL 1(R11), R11
+
+repeat_extend_forward_end_encodeBlockAsm8B:
+        ADDL  R11, CX
+        MOVL  CX, BX
+        SUBL  SI, BX
+        MOVL  16(SP), SI
+        TESTL DI, DI
+        JZ    repeat_as_copy_encodeBlockAsm8B
+
+        // emitRepeat
+        MOVL BX, SI
+        LEAL -4(BX), BX
+        CMPL SI, $0x08
+        JBE  repeat_two_match_repeat_encodeBlockAsm8B
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_match_repeat_encodeBlockAsm8B
+
+cant_repeat_two_offset_match_repeat_encodeBlockAsm8B:
+        CMPL BX, $0x00000104
+        JB   repeat_three_match_repeat_encodeBlockAsm8B
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm8B
+
+repeat_three_match_repeat_encodeBlockAsm8B:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm8B
+
+repeat_two_match_repeat_encodeBlockAsm8B:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm8B
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm8B
+
+repeat_as_copy_encodeBlockAsm8B:
+        // emitCopy
+        CMPL BX, $0x40
+        JBE  two_byte_offset_short_repeat_as_copy_encodeBlockAsm8B
+        CMPL SI, $0x00000800
+        JAE  long_offset_short_repeat_as_copy_encodeBlockAsm8B
+        MOVL $0x00000001, DI
+        LEAL 16(DI), DI
+        MOVB SI, 1(AX)
+        SHRL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, BX
+
+        // emitRepeat
+        LEAL -4(BX), BX
+        JMP  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm8B_emit_copy_short_2b
+        MOVL BX, SI
+        LEAL -4(BX), BX
+        CMPL SI, $0x08
+        JBE  repeat_two_repeat_as_copy_encodeBlockAsm8B_emit_copy_short_2b
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm8B_emit_copy_short_2b
+
+cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm8B_emit_copy_short_2b:
+        CMPL BX, $0x00000104
+        JB   repeat_three_repeat_as_copy_encodeBlockAsm8B_emit_copy_short_2b
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm8B
+
+repeat_three_repeat_as_copy_encodeBlockAsm8B_emit_copy_short_2b:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm8B
+
+repeat_two_repeat_as_copy_encodeBlockAsm8B_emit_copy_short_2b:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm8B
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm8B
+
+long_offset_short_repeat_as_copy_encodeBlockAsm8B:
+        MOVB $0xee, (AX)
+        MOVW SI, 1(AX)
+        LEAL -60(BX), BX
+        ADDQ $0x03, AX
+
+        // emitRepeat
+        MOVL BX, SI
+        LEAL -4(BX), BX
+        CMPL SI, $0x08
+        JBE  repeat_two_repeat_as_copy_encodeBlockAsm8B_emit_copy_short
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm8B_emit_copy_short
+
+cant_repeat_two_offset_repeat_as_copy_encodeBlockAsm8B_emit_copy_short:
+        CMPL BX, $0x00000104
+        JB   repeat_three_repeat_as_copy_encodeBlockAsm8B_emit_copy_short
+        LEAL -256(BX), BX
+        MOVW $0x0019, (AX)
+        MOVW BX, 2(AX)
+        ADDQ $0x04, AX
+        JMP  repeat_end_emit_encodeBlockAsm8B
+
+repeat_three_repeat_as_copy_encodeBlockAsm8B_emit_copy_short:
+        LEAL -4(BX), BX
+        MOVW $0x0015, (AX)
+        MOVB BL, 2(AX)
+        ADDQ $0x03, AX
+        JMP  repeat_end_emit_encodeBlockAsm8B
+
+repeat_two_repeat_as_copy_encodeBlockAsm8B_emit_copy_short:
+        SHLL $0x02, BX
+        ORL  $0x01, BX
+        MOVW BX, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm8B
+        XORQ DI, DI
+        LEAL 1(DI)(BX*4), BX
+        MOVB SI, 1(AX)
+        SARL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm8B
+
+two_byte_offset_short_repeat_as_copy_encodeBlockAsm8B:
+        MOVL BX, DI
+        SHLL $0x02, DI
+        CMPL BX, $0x0c
+        JAE  emit_copy_three_repeat_as_copy_encodeBlockAsm8B
+        LEAL -15(DI), DI
+        MOVB SI, 1(AX)
+        SHRL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeBlockAsm8B
+
+emit_copy_three_repeat_as_copy_encodeBlockAsm8B:
+        LEAL -2(DI), DI
+        MOVB DI, (AX)
+        MOVW SI, 1(AX)
+        ADDQ $0x03, AX
+
+repeat_end_emit_encodeBlockAsm8B:
+        MOVL CX, 12(SP)
+        JMP  search_loop_encodeBlockAsm8B
+
+no_repeat_found_encodeBlockAsm8B:
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate_match_encodeBlockAsm8B
+        SHRQ $0x08, SI
+        MOVL 24(SP)(R9*4), BX
+        LEAL 2(CX), R8
+        CMPL (DX)(DI*1), SI
+        JEQ  candidate2_match_encodeBlockAsm8B
+        MOVL R8, 24(SP)(R9*4)
+        SHRQ $0x08, SI
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate3_match_encodeBlockAsm8B
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeBlockAsm8B
+
+candidate3_match_encodeBlockAsm8B:
+        ADDL $0x02, CX
+        JMP  candidate_match_encodeBlockAsm8B
+
+candidate2_match_encodeBlockAsm8B:
+        MOVL R8, 24(SP)(R9*4)
+        INCL CX
+        MOVL DI, BX
+
+candidate_match_encodeBlockAsm8B:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeBlockAsm8B
+
+match_extend_back_loop_encodeBlockAsm8B:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeBlockAsm8B
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeBlockAsm8B
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeBlockAsm8B
+        JMP  match_extend_back_loop_encodeBlockAsm8B
+
+match_extend_back_end_encodeBlockAsm8B:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeBlockAsm8B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeBlockAsm8B:
+        MOVL CX, SI
+        MOVL 12(SP), DI
+        CMPL DI, SI
+        JEQ  emit_literal_done_match_emit_encodeBlockAsm8B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(DI*1), SI
+        SUBL DI, R8
+        LEAL -1(R8), DI
+        CMPL DI, $0x3c
+        JB   one_byte_match_emit_encodeBlockAsm8B
+        CMPL DI, $0x00000100
+        JB   two_bytes_match_emit_encodeBlockAsm8B
+        JB   three_bytes_match_emit_encodeBlockAsm8B
+
+three_bytes_match_emit_encodeBlockAsm8B:
+        MOVB $0xf4, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeBlockAsm8B
+
+two_bytes_match_emit_encodeBlockAsm8B:
+        MOVB $0xf0, (AX)
+        MOVB DI, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DI, $0x40
+        JB   memmove_match_emit_encodeBlockAsm8B
+        JMP  memmove_long_match_emit_encodeBlockAsm8B
+
+one_byte_match_emit_encodeBlockAsm8B:
+        SHLB $0x02, DI
+        MOVB DI, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeBlockAsm8B:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm8B_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm8B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeBlockAsm8B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeBlockAsm8B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeBlockAsm8B_memmove_move_8:
+        MOVQ (SI), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_match_emit_encodeBlockAsm8B
+
+emit_lit_memmove_match_emit_encodeBlockAsm8B_memmove_move_8through16:
+        MOVQ (SI), R9
+        MOVQ -8(SI)(R8*1), SI
+        MOVQ R9, (AX)
+        MOVQ SI, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBlockAsm8B
+
+emit_lit_memmove_match_emit_encodeBlockAsm8B_memmove_move_17through32:
+        MOVOU (SI), X0
+        MOVOU -16(SI)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeBlockAsm8B
+
+emit_lit_memmove_match_emit_encodeBlockAsm8B_memmove_move_33through64:
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeBlockAsm8B:
+        MOVQ DI, AX
+        JMP  emit_literal_done_match_emit_encodeBlockAsm8B
+
+memmove_long_match_emit_encodeBlockAsm8B:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveLong
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVQ  R8, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_match_emit_encodeBlockAsm8Blarge_forward_sse_loop_32
+        LEAQ  -32(SI)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_match_emit_encodeBlockAsm8Blarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_match_emit_encodeBlockAsm8Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeBlockAsm8Blarge_forward_sse_loop_32:
+        MOVOU -32(SI)(R11*1), X4
+        MOVOU -16(SI)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  R8, R11
+        JAE   emit_lit_memmove_long_match_emit_encodeBlockAsm8Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  DI, AX
+
+emit_literal_done_match_emit_encodeBlockAsm8B:
+match_nolit_loop_encodeBlockAsm8B:
+        MOVL CX, SI
+        SUBL BX, SI
+        MOVL SI, 16(SP)
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), SI
+        SUBL CX, SI
+        LEAQ (DX)(CX*1), DI
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R9, R9
+
+matchlen_loopback_16_match_nolit_encodeBlockAsm8B:
+        CMPL SI, $0x10
+        JB   matchlen_match8_match_nolit_encodeBlockAsm8B
+        MOVQ (DI)(R9*1), R8
+        MOVQ 8(DI)(R9*1), R10
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeBlockAsm8B
+        XORQ 8(BX)(R9*1), R10
+        JNZ  matchlen_bsf_16match_nolit_encodeBlockAsm8B
+        LEAL -16(SI), SI
+        LEAL 16(R9), R9
+        JMP  matchlen_loopback_16_match_nolit_encodeBlockAsm8B
+
+matchlen_bsf_16match_nolit_encodeBlockAsm8B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL 8(R9)(R10*1), R9
+        JMP  match_nolit_end_encodeBlockAsm8B
+
+matchlen_match8_match_nolit_encodeBlockAsm8B:
+        CMPL SI, $0x08
+        JB   matchlen_match4_match_nolit_encodeBlockAsm8B
+        MOVQ (DI)(R9*1), R8
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeBlockAsm8B
+        LEAL -8(SI), SI
+        LEAL 8(R9), R9
+        JMP  matchlen_match4_match_nolit_encodeBlockAsm8B
+
+matchlen_bsf_8_match_nolit_encodeBlockAsm8B:
+#ifdef GOAMD64_v3
+        TZCNTQ R8, R8
+
+#else
+        BSFQ R8, R8
+
+#endif
+        SARQ $0x03, R8
+        LEAL (R9)(R8*1), R9
+        JMP  match_nolit_end_encodeBlockAsm8B
+
+matchlen_match4_match_nolit_encodeBlockAsm8B:
+        CMPL SI, $0x04
+        JB   matchlen_match2_match_nolit_encodeBlockAsm8B
+        MOVL (DI)(R9*1), R8
+        CMPL (BX)(R9*1), R8
+        JNE  matchlen_match2_match_nolit_encodeBlockAsm8B
+        LEAL -4(SI), SI
+        LEAL 4(R9), R9
+
+matchlen_match2_match_nolit_encodeBlockAsm8B:
+        CMPL SI, $0x01
+        JE   matchlen_match1_match_nolit_encodeBlockAsm8B
+        JB   match_nolit_end_encodeBlockAsm8B
+        MOVW (DI)(R9*1), R8
+        CMPW (BX)(R9*1), R8
+        JNE  matchlen_match1_match_nolit_encodeBlockAsm8B
+        LEAL 2(R9), R9
+        SUBL $0x02, SI
+        JZ   match_nolit_end_encodeBlockAsm8B
+
+matchlen_match1_match_nolit_encodeBlockAsm8B:
+        MOVB (DI)(R9*1), R8
+        CMPB (BX)(R9*1), R8
+        JNE  match_nolit_end_encodeBlockAsm8B
+        LEAL 1(R9), R9
+
+match_nolit_end_encodeBlockAsm8B:
+        ADDL R9, CX
+        MOVL 16(SP), BX
+        ADDL $0x04, R9
+        MOVL CX, 12(SP)
+
+        // emitCopy
+        CMPL R9, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeBlockAsm8B
+        CMPL BX, $0x00000800
+        JAE  long_offset_short_match_nolit_encodeBlockAsm8B
+        MOVL $0x00000001, SI
+        LEAL 16(SI), SI
+        MOVB BL, 1(AX)
+        SHRL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, R9
+
+        // emitRepeat
+        LEAL -4(R9), R9
+        JMP  cant_repeat_two_offset_match_nolit_encodeBlockAsm8B_emit_copy_short_2b
+        MOVL R9, BX
+        LEAL -4(R9), R9
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_encodeBlockAsm8B_emit_copy_short_2b
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBlockAsm8B_emit_copy_short_2b
+
+cant_repeat_two_offset_match_nolit_encodeBlockAsm8B_emit_copy_short_2b:
+        CMPL R9, $0x00000104
+        JB   repeat_three_match_nolit_encodeBlockAsm8B_emit_copy_short_2b
+        LEAL -256(R9), R9
+        MOVW $0x0019, (AX)
+        MOVW R9, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm8B
+
+repeat_three_match_nolit_encodeBlockAsm8B_emit_copy_short_2b:
+        LEAL -4(R9), R9
+        MOVW $0x0015, (AX)
+        MOVB R9, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm8B
+
+repeat_two_match_nolit_encodeBlockAsm8B_emit_copy_short_2b:
+        SHLL $0x02, R9
+        ORL  $0x01, R9
+        MOVW R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm8B
+        XORQ SI, SI
+        LEAL 1(SI)(R9*4), R9
+        MOVB BL, 1(AX)
+        SARL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, R9
+        MOVB R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm8B
+
+long_offset_short_match_nolit_encodeBlockAsm8B:
+        MOVB $0xee, (AX)
+        MOVW BX, 1(AX)
+        LEAL -60(R9), R9
+        ADDQ $0x03, AX
+
+        // emitRepeat
+        MOVL R9, BX
+        LEAL -4(R9), R9
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_encodeBlockAsm8B_emit_copy_short
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBlockAsm8B_emit_copy_short
+
+cant_repeat_two_offset_match_nolit_encodeBlockAsm8B_emit_copy_short:
+        CMPL R9, $0x00000104
+        JB   repeat_three_match_nolit_encodeBlockAsm8B_emit_copy_short
+        LEAL -256(R9), R9
+        MOVW $0x0019, (AX)
+        MOVW R9, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm8B
+
+repeat_three_match_nolit_encodeBlockAsm8B_emit_copy_short:
+        LEAL -4(R9), R9
+        MOVW $0x0015, (AX)
+        MOVB R9, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm8B
+
+repeat_two_match_nolit_encodeBlockAsm8B_emit_copy_short:
+        SHLL $0x02, R9
+        ORL  $0x01, R9
+        MOVW R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm8B
+        XORQ SI, SI
+        LEAL 1(SI)(R9*4), R9
+        MOVB BL, 1(AX)
+        SARL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, R9
+        MOVB R9, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm8B
+
+two_byte_offset_short_match_nolit_encodeBlockAsm8B:
+        MOVL R9, SI
+        SHLL $0x02, SI
+        CMPL R9, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeBlockAsm8B
+        LEAL -15(SI), SI
+        MOVB BL, 1(AX)
+        SHRL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBlockAsm8B
+
+emit_copy_three_match_nolit_encodeBlockAsm8B:
+        LEAL -2(SI), SI
+        MOVB SI, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeBlockAsm8B:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeBlockAsm8B
+        MOVQ -2(DX)(CX*1), SI
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeBlockAsm8B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeBlockAsm8B:
+        MOVQ  $0x9e3779b1, R8
+        MOVQ  SI, DI
+        SHRQ  $0x10, SI
+        MOVQ  SI, BX
+        SHLQ  $0x20, DI
+        IMULQ R8, DI
+        SHRQ  $0x38, DI
+        SHLQ  $0x20, BX
+        IMULQ R8, BX
+        SHRQ  $0x38, BX
+        LEAL  -2(CX), R8
+        LEAQ  24(SP)(BX*4), R9
+        MOVL  (R9), BX
+        MOVL  R8, 24(SP)(DI*4)
+        MOVL  CX, (R9)
+        CMPL  (DX)(BX*1), SI
+        JEQ   match_nolit_loop_encodeBlockAsm8B
+        INCL  CX
+        JMP   search_loop_encodeBlockAsm8B
+
+emit_remainder_encodeBlockAsm8B:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeBlockAsm8B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeBlockAsm8B:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeBlockAsm8B
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeBlockAsm8B
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeBlockAsm8B
+        JB   three_bytes_emit_remainder_encodeBlockAsm8B
+
+three_bytes_emit_remainder_encodeBlockAsm8B:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeBlockAsm8B
+
+two_bytes_emit_remainder_encodeBlockAsm8B:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeBlockAsm8B
+        JMP  memmove_long_emit_remainder_encodeBlockAsm8B
+
+one_byte_emit_remainder_encodeBlockAsm8B:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeBlockAsm8B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeBlockAsm8B_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeBlockAsm8B_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeBlockAsm8B_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeBlockAsm8B_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeBlockAsm8B_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeBlockAsm8B_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm8B_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm8B_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm8B_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm8B_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm8B_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeBlockAsm8B_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeBlockAsm8B:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeBlockAsm8B
+
+memmove_long_emit_remainder_encodeBlockAsm8B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeBlockAsm8Blarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeBlockAsm8Blarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeBlockAsm8Blarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeBlockAsm8Blarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeBlockAsm8Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeBlockAsm8B:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeBetterBlockAsm(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeBetterBlockAsm(SB), $589848-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00001200, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeBetterBlockAsm:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeBetterBlockAsm
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -6(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  $0x00000000, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeBetterBlockAsm:
+        MOVL CX, BX
+        SUBL 12(SP), BX
+        SHRL $0x07, BX
+        CMPL BX, $0x63
+        JBE  check_maxskip_ok_encodeBetterBlockAsm
+        LEAL 100(CX), BX
+        JMP  check_maxskip_cont_encodeBetterBlockAsm
+
+check_maxskip_ok_encodeBetterBlockAsm:
+        LEAL 1(CX)(BX*1), BX
+
+check_maxskip_cont_encodeBetterBlockAsm:
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeBetterBlockAsm
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x00cf1bbcdcbfa563, R8
+        MOVQ  $0x9e3779b1, BX
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHLQ  $0x08, R9
+        IMULQ R8, R9
+        SHRQ  $0x2f, R9
+        SHLQ  $0x20, R10
+        IMULQ BX, R10
+        SHRQ  $0x32, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  524312(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        MOVL  CX, 524312(SP)(R10*4)
+        MOVQ  (DX)(BX*1), R9
+        MOVQ  (DX)(DI*1), R10
+        CMPQ  R9, SI
+        JEQ   candidate_match_encodeBetterBlockAsm
+        CMPQ  R10, SI
+        JNE   no_short_found_encodeBetterBlockAsm
+        MOVL  DI, BX
+        JMP   candidate_match_encodeBetterBlockAsm
+
+no_short_found_encodeBetterBlockAsm:
+        CMPL R9, SI
+        JEQ  candidate_match_encodeBetterBlockAsm
+        CMPL R10, SI
+        JEQ  candidateS_match_encodeBetterBlockAsm
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeBetterBlockAsm
+
+candidateS_match_encodeBetterBlockAsm:
+        SHRQ  $0x08, SI
+        MOVQ  SI, R9
+        SHLQ  $0x08, R9
+        IMULQ R8, R9
+        SHRQ  $0x2f, R9
+        MOVL  24(SP)(R9*4), BX
+        INCL  CX
+        MOVL  CX, 24(SP)(R9*4)
+        CMPL  (DX)(BX*1), SI
+        JEQ   candidate_match_encodeBetterBlockAsm
+        DECL  CX
+        MOVL  DI, BX
+
+candidate_match_encodeBetterBlockAsm:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeBetterBlockAsm
+
+match_extend_back_loop_encodeBetterBlockAsm:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeBetterBlockAsm
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeBetterBlockAsm
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeBetterBlockAsm
+        JMP  match_extend_back_loop_encodeBetterBlockAsm
+
+match_extend_back_end_encodeBetterBlockAsm:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 5(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeBetterBlockAsm
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeBetterBlockAsm:
+        MOVL CX, SI
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), R9
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_match_nolit_encodeBetterBlockAsm:
+        CMPL DI, $0x10
+        JB   matchlen_match8_match_nolit_encodeBetterBlockAsm
+        MOVQ (R8)(R11*1), R10
+        MOVQ 8(R8)(R11*1), R12
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeBetterBlockAsm
+        XORQ 8(R9)(R11*1), R12
+        JNZ  matchlen_bsf_16match_nolit_encodeBetterBlockAsm
+        LEAL -16(DI), DI
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_match_nolit_encodeBetterBlockAsm
+
+matchlen_bsf_16match_nolit_encodeBetterBlockAsm:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  match_nolit_end_encodeBetterBlockAsm
+
+matchlen_match8_match_nolit_encodeBetterBlockAsm:
+        CMPL DI, $0x08
+        JB   matchlen_match4_match_nolit_encodeBetterBlockAsm
+        MOVQ (R8)(R11*1), R10
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeBetterBlockAsm
+        LEAL -8(DI), DI
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_match_nolit_encodeBetterBlockAsm
+
+matchlen_bsf_8_match_nolit_encodeBetterBlockAsm:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  match_nolit_end_encodeBetterBlockAsm
+
+matchlen_match4_match_nolit_encodeBetterBlockAsm:
+        CMPL DI, $0x04
+        JB   matchlen_match2_match_nolit_encodeBetterBlockAsm
+        MOVL (R8)(R11*1), R10
+        CMPL (R9)(R11*1), R10
+        JNE  matchlen_match2_match_nolit_encodeBetterBlockAsm
+        LEAL -4(DI), DI
+        LEAL 4(R11), R11
+
+matchlen_match2_match_nolit_encodeBetterBlockAsm:
+        CMPL DI, $0x01
+        JE   matchlen_match1_match_nolit_encodeBetterBlockAsm
+        JB   match_nolit_end_encodeBetterBlockAsm
+        MOVW (R8)(R11*1), R10
+        CMPW (R9)(R11*1), R10
+        JNE  matchlen_match1_match_nolit_encodeBetterBlockAsm
+        LEAL 2(R11), R11
+        SUBL $0x02, DI
+        JZ   match_nolit_end_encodeBetterBlockAsm
+
+matchlen_match1_match_nolit_encodeBetterBlockAsm:
+        MOVB (R8)(R11*1), R10
+        CMPB (R9)(R11*1), R10
+        JNE  match_nolit_end_encodeBetterBlockAsm
+        LEAL 1(R11), R11
+
+match_nolit_end_encodeBetterBlockAsm:
+        MOVL CX, DI
+        SUBL BX, DI
+
+        // Check if repeat
+        CMPL 16(SP), DI
+        JEQ  match_is_repeat_encodeBetterBlockAsm
+        CMPL R11, $0x01
+        JA   match_length_ok_encodeBetterBlockAsm
+        CMPL DI, $0x0000ffff
+        JBE  match_length_ok_encodeBetterBlockAsm
+        MOVL 20(SP), CX
+        INCL CX
+        JMP  search_loop_encodeBetterBlockAsm
+
+match_length_ok_encodeBetterBlockAsm:
+        MOVL DI, 16(SP)
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_encodeBetterBlockAsm
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_encodeBetterBlockAsm
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_encodeBetterBlockAsm
+        CMPL BX, $0x00010000
+        JB   three_bytes_match_emit_encodeBetterBlockAsm
+        CMPL BX, $0x01000000
+        JB   four_bytes_match_emit_encodeBetterBlockAsm
+        MOVB $0xfc, (AX)
+        MOVL BX, 1(AX)
+        ADDQ $0x05, AX
+        JMP  memmove_long_match_emit_encodeBetterBlockAsm
+
+four_bytes_match_emit_encodeBetterBlockAsm:
+        MOVL BX, R10
+        SHRL $0x10, R10
+        MOVB $0xf8, (AX)
+        MOVW BX, 1(AX)
+        MOVB R10, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_match_emit_encodeBetterBlockAsm
+
+three_bytes_match_emit_encodeBetterBlockAsm:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeBetterBlockAsm
+
+two_bytes_match_emit_encodeBetterBlockAsm:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_encodeBetterBlockAsm
+        JMP  memmove_long_match_emit_encodeBetterBlockAsm
+
+one_byte_match_emit_encodeBetterBlockAsm:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeBetterBlockAsm:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x04
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm_memmove_move_4
+        CMPQ R8, $0x08
+        JB   emit_lit_memmove_match_emit_encodeBetterBlockAsm_memmove_move_4through7
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeBetterBlockAsm_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm_memmove_move_4:
+        MOVL (R9), R10
+        MOVL R10, (AX)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm_memmove_move_4through7:
+        MOVL (R9), R10
+        MOVL -4(R9)(R8*1), R9
+        MOVL R10, (AX)
+        MOVL R9, -4(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeBetterBlockAsm
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeBetterBlockAsm:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_encodeBetterBlockAsm
+
+memmove_long_match_emit_encodeBetterBlockAsm:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R13
+        SUBQ  R10, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_match_emit_encodeBetterBlockAsmlarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R13*1), R10
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_match_emit_encodeBetterBlockAsmlarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_match_emit_encodeBetterBlockAsmlarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeBetterBlockAsmlarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R13*1), X4
+        MOVOU -16(R9)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_match_emit_encodeBetterBlockAsmlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_encodeBetterBlockAsm:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitCopy
+        CMPL DI, $0x00010000
+        JB   two_byte_offset_match_nolit_encodeBetterBlockAsm
+        CMPL R11, $0x40
+        JBE  four_bytes_remain_match_nolit_encodeBetterBlockAsm
+        MOVB $0xff, (AX)
+        MOVL DI, 1(AX)
+        LEAL -64(R11), R11
+        ADDQ $0x05, AX
+        CMPL R11, $0x04
+        JB   four_bytes_remain_match_nolit_encodeBetterBlockAsm
+
+        // emitRepeat
+emit_repeat_again_match_nolit_encodeBetterBlockAsm_emit_copy:
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_encodeBetterBlockAsm_emit_copy
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm_emit_copy
+        CMPL DI, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBetterBlockAsm_emit_copy
+
+cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm_emit_copy:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_encodeBetterBlockAsm_emit_copy
+        CMPL R11, $0x00010100
+        JB   repeat_four_match_nolit_encodeBetterBlockAsm_emit_copy
+        CMPL R11, $0x0100ffff
+        JB   repeat_five_match_nolit_encodeBetterBlockAsm_emit_copy
+        LEAL -16842747(R11), R11
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_match_nolit_encodeBetterBlockAsm_emit_copy
+
+repeat_five_match_nolit_encodeBetterBlockAsm_emit_copy:
+        LEAL -65536(R11), R11
+        MOVL R11, DI
+        MOVW $0x001d, (AX)
+        MOVW R11, 2(AX)
+        SARL $0x10, DI
+        MOVB DI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_four_match_nolit_encodeBetterBlockAsm_emit_copy:
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_three_match_nolit_encodeBetterBlockAsm_emit_copy:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_two_match_nolit_encodeBetterBlockAsm_emit_copy:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_two_offset_match_nolit_encodeBetterBlockAsm_emit_copy:
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+four_bytes_remain_match_nolit_encodeBetterBlockAsm:
+        TESTL R11, R11
+        JZ    match_nolit_emitcopy_end_encodeBetterBlockAsm
+        XORL  BX, BX
+        LEAL  -1(BX)(R11*4), R11
+        MOVB  R11, (AX)
+        MOVL  DI, 1(AX)
+        ADDQ  $0x05, AX
+        JMP   match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+two_byte_offset_match_nolit_encodeBetterBlockAsm:
+        CMPL R11, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeBetterBlockAsm
+        CMPL DI, $0x00000800
+        JAE  long_offset_short_match_nolit_encodeBetterBlockAsm
+        MOVL $0x00000001, BX
+        LEAL 16(BX), BX
+        MOVB DI, 1(AX)
+        MOVL DI, R8
+        SHRL $0x08, R8
+        SHLL $0x05, R8
+        ORL  R8, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, R11
+
+        // emitRepeat
+        LEAL -4(R11), R11
+        JMP  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b
+
+emit_repeat_again_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b:
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b
+        CMPL DI, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b
+
+cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b
+        CMPL R11, $0x00010100
+        JB   repeat_four_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b
+        CMPL R11, $0x0100ffff
+        JB   repeat_five_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b
+        LEAL -16842747(R11), R11
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b
+
+repeat_five_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b:
+        LEAL -65536(R11), R11
+        MOVL R11, DI
+        MOVW $0x001d, (AX)
+        MOVW R11, 2(AX)
+        SARL $0x10, DI
+        MOVB DI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_four_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b:
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_three_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_two_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_two_offset_match_nolit_encodeBetterBlockAsm_emit_copy_short_2b:
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+long_offset_short_match_nolit_encodeBetterBlockAsm:
+        MOVB $0xee, (AX)
+        MOVW DI, 1(AX)
+        LEAL -60(R11), R11
+        ADDQ $0x03, AX
+
+        // emitRepeat
+emit_repeat_again_match_nolit_encodeBetterBlockAsm_emit_copy_short:
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_encodeBetterBlockAsm_emit_copy_short
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm_emit_copy_short
+        CMPL DI, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBetterBlockAsm_emit_copy_short
+
+cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm_emit_copy_short:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_encodeBetterBlockAsm_emit_copy_short
+        CMPL R11, $0x00010100
+        JB   repeat_four_match_nolit_encodeBetterBlockAsm_emit_copy_short
+        CMPL R11, $0x0100ffff
+        JB   repeat_five_match_nolit_encodeBetterBlockAsm_emit_copy_short
+        LEAL -16842747(R11), R11
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_match_nolit_encodeBetterBlockAsm_emit_copy_short
+
+repeat_five_match_nolit_encodeBetterBlockAsm_emit_copy_short:
+        LEAL -65536(R11), R11
+        MOVL R11, DI
+        MOVW $0x001d, (AX)
+        MOVW R11, 2(AX)
+        SARL $0x10, DI
+        MOVB DI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_four_match_nolit_encodeBetterBlockAsm_emit_copy_short:
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_three_match_nolit_encodeBetterBlockAsm_emit_copy_short:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_two_match_nolit_encodeBetterBlockAsm_emit_copy_short:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_two_offset_match_nolit_encodeBetterBlockAsm_emit_copy_short:
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+two_byte_offset_short_match_nolit_encodeBetterBlockAsm:
+        MOVL R11, BX
+        SHLL $0x02, BX
+        CMPL R11, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeBetterBlockAsm
+        CMPL DI, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeBetterBlockAsm
+        LEAL -15(BX), BX
+        MOVB DI, 1(AX)
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+emit_copy_three_match_nolit_encodeBetterBlockAsm:
+        LEAL -2(BX), BX
+        MOVB BL, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+match_is_repeat_encodeBetterBlockAsm:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_repeat_encodeBetterBlockAsm
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_repeat_encodeBetterBlockAsm
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_repeat_encodeBetterBlockAsm
+        CMPL BX, $0x00010000
+        JB   three_bytes_match_emit_repeat_encodeBetterBlockAsm
+        CMPL BX, $0x01000000
+        JB   four_bytes_match_emit_repeat_encodeBetterBlockAsm
+        MOVB $0xfc, (AX)
+        MOVL BX, 1(AX)
+        ADDQ $0x05, AX
+        JMP  memmove_long_match_emit_repeat_encodeBetterBlockAsm
+
+four_bytes_match_emit_repeat_encodeBetterBlockAsm:
+        MOVL BX, R10
+        SHRL $0x10, R10
+        MOVB $0xf8, (AX)
+        MOVW BX, 1(AX)
+        MOVB R10, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_match_emit_repeat_encodeBetterBlockAsm
+
+three_bytes_match_emit_repeat_encodeBetterBlockAsm:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_repeat_encodeBetterBlockAsm
+
+two_bytes_match_emit_repeat_encodeBetterBlockAsm:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_repeat_encodeBetterBlockAsm
+        JMP  memmove_long_match_emit_repeat_encodeBetterBlockAsm
+
+one_byte_match_emit_repeat_encodeBetterBlockAsm:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_repeat_encodeBetterBlockAsm:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x04
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm_memmove_move_4
+        CMPQ R8, $0x08
+        JB   emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm_memmove_move_4through7
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm_memmove_move_33through64
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm_memmove_move_4:
+        MOVL (R9), R10
+        MOVL R10, (AX)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm_memmove_move_4through7:
+        MOVL (R9), R10
+        MOVL -4(R9)(R8*1), R9
+        MOVL R10, (AX)
+        MOVL R9, -4(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_repeat_encodeBetterBlockAsm
+
+memmove_long_match_emit_repeat_encodeBetterBlockAsm:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R13
+        SUBQ  R10, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsmlarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R13*1), R10
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsmlarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsmlarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsmlarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R13*1), X4
+        MOVOU -16(R9)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsmlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_repeat_encodeBetterBlockAsm:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitRepeat
+emit_repeat_again_match_nolit_repeat_encodeBetterBlockAsm:
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_repeat_encodeBetterBlockAsm
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm
+        CMPL DI, $0x00000800
+        JB   repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm
+
+cant_repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_repeat_encodeBetterBlockAsm
+        CMPL R11, $0x00010100
+        JB   repeat_four_match_nolit_repeat_encodeBetterBlockAsm
+        CMPL R11, $0x0100ffff
+        JB   repeat_five_match_nolit_repeat_encodeBetterBlockAsm
+        LEAL -16842747(R11), R11
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_match_nolit_repeat_encodeBetterBlockAsm
+
+repeat_five_match_nolit_repeat_encodeBetterBlockAsm:
+        LEAL -65536(R11), R11
+        MOVL R11, DI
+        MOVW $0x001d, (AX)
+        MOVW R11, 2(AX)
+        SARL $0x10, DI
+        MOVB DI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_four_match_nolit_repeat_encodeBetterBlockAsm:
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_three_match_nolit_repeat_encodeBetterBlockAsm:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_two_match_nolit_repeat_encodeBetterBlockAsm:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm
+
+repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm:
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+
+match_nolit_emitcopy_end_encodeBetterBlockAsm:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeBetterBlockAsm
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeBetterBlockAsm
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeBetterBlockAsm:
+        MOVQ  $0x00cf1bbcdcbfa563, BX
+        MOVQ  $0x9e3779b1, DI
+        LEAQ  1(SI), SI
+        LEAQ  -2(CX), R8
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  1(DX)(SI*1), R10
+        MOVQ  (DX)(R8*1), R11
+        MOVQ  1(DX)(R8*1), R12
+        SHLQ  $0x08, R9
+        IMULQ BX, R9
+        SHRQ  $0x2f, R9
+        SHLQ  $0x20, R10
+        IMULQ DI, R10
+        SHRQ  $0x32, R10
+        SHLQ  $0x08, R11
+        IMULQ BX, R11
+        SHRQ  $0x2f, R11
+        SHLQ  $0x20, R12
+        IMULQ DI, R12
+        SHRQ  $0x32, R12
+        LEAQ  1(SI), DI
+        LEAQ  1(R8), R13
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  R8, 24(SP)(R11*4)
+        MOVL  DI, 524312(SP)(R10*4)
+        MOVL  R13, 524312(SP)(R12*4)
+        LEAQ  1(R8)(SI*1), DI
+        SHRQ  $0x01, DI
+        ADDQ  $0x01, SI
+        SUBQ  $0x01, R8
+
+index_loop_encodeBetterBlockAsm:
+        CMPQ  DI, R8
+        JAE   search_loop_encodeBetterBlockAsm
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  (DX)(DI*1), R10
+        SHLQ  $0x08, R9
+        IMULQ BX, R9
+        SHRQ  $0x2f, R9
+        SHLQ  $0x08, R10
+        IMULQ BX, R10
+        SHRQ  $0x2f, R10
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  DI, 24(SP)(R10*4)
+        ADDQ  $0x02, SI
+        ADDQ  $0x02, DI
+        JMP   index_loop_encodeBetterBlockAsm
+
+emit_remainder_encodeBetterBlockAsm:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 5(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeBetterBlockAsm
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeBetterBlockAsm:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeBetterBlockAsm
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeBetterBlockAsm
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeBetterBlockAsm
+        CMPL DX, $0x00010000
+        JB   three_bytes_emit_remainder_encodeBetterBlockAsm
+        CMPL DX, $0x01000000
+        JB   four_bytes_emit_remainder_encodeBetterBlockAsm
+        MOVB $0xfc, (AX)
+        MOVL DX, 1(AX)
+        ADDQ $0x05, AX
+        JMP  memmove_long_emit_remainder_encodeBetterBlockAsm
+
+four_bytes_emit_remainder_encodeBetterBlockAsm:
+        MOVL DX, BX
+        SHRL $0x10, BX
+        MOVB $0xf8, (AX)
+        MOVW DX, 1(AX)
+        MOVB BL, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_emit_remainder_encodeBetterBlockAsm
+
+three_bytes_emit_remainder_encodeBetterBlockAsm:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeBetterBlockAsm
+
+two_bytes_emit_remainder_encodeBetterBlockAsm:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeBetterBlockAsm
+        JMP  memmove_long_emit_remainder_encodeBetterBlockAsm
+
+one_byte_emit_remainder_encodeBetterBlockAsm:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeBetterBlockAsm:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeBetterBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeBetterBlockAsm:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeBetterBlockAsm
+
+memmove_long_emit_remainder_encodeBetterBlockAsm:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsmlarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsmlarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsmlarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsmlarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsmlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeBetterBlockAsm:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeBetterBlockAsm4MB(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeBetterBlockAsm4MB(SB), $589848-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00001200, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeBetterBlockAsm4MB:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeBetterBlockAsm4MB
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -6(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  $0x00000000, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeBetterBlockAsm4MB:
+        MOVL CX, BX
+        SUBL 12(SP), BX
+        SHRL $0x07, BX
+        CMPL BX, $0x63
+        JBE  check_maxskip_ok_encodeBetterBlockAsm4MB
+        LEAL 100(CX), BX
+        JMP  check_maxskip_cont_encodeBetterBlockAsm4MB
+
+check_maxskip_ok_encodeBetterBlockAsm4MB:
+        LEAL 1(CX)(BX*1), BX
+
+check_maxskip_cont_encodeBetterBlockAsm4MB:
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeBetterBlockAsm4MB
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x00cf1bbcdcbfa563, R8
+        MOVQ  $0x9e3779b1, BX
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHLQ  $0x08, R9
+        IMULQ R8, R9
+        SHRQ  $0x2f, R9
+        SHLQ  $0x20, R10
+        IMULQ BX, R10
+        SHRQ  $0x32, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  524312(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        MOVL  CX, 524312(SP)(R10*4)
+        MOVQ  (DX)(BX*1), R9
+        MOVQ  (DX)(DI*1), R10
+        CMPQ  R9, SI
+        JEQ   candidate_match_encodeBetterBlockAsm4MB
+        CMPQ  R10, SI
+        JNE   no_short_found_encodeBetterBlockAsm4MB
+        MOVL  DI, BX
+        JMP   candidate_match_encodeBetterBlockAsm4MB
+
+no_short_found_encodeBetterBlockAsm4MB:
+        CMPL R9, SI
+        JEQ  candidate_match_encodeBetterBlockAsm4MB
+        CMPL R10, SI
+        JEQ  candidateS_match_encodeBetterBlockAsm4MB
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeBetterBlockAsm4MB
+
+candidateS_match_encodeBetterBlockAsm4MB:
+        SHRQ  $0x08, SI
+        MOVQ  SI, R9
+        SHLQ  $0x08, R9
+        IMULQ R8, R9
+        SHRQ  $0x2f, R9
+        MOVL  24(SP)(R9*4), BX
+        INCL  CX
+        MOVL  CX, 24(SP)(R9*4)
+        CMPL  (DX)(BX*1), SI
+        JEQ   candidate_match_encodeBetterBlockAsm4MB
+        DECL  CX
+        MOVL  DI, BX
+
+candidate_match_encodeBetterBlockAsm4MB:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeBetterBlockAsm4MB
+
+match_extend_back_loop_encodeBetterBlockAsm4MB:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeBetterBlockAsm4MB
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeBetterBlockAsm4MB
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeBetterBlockAsm4MB
+        JMP  match_extend_back_loop_encodeBetterBlockAsm4MB
+
+match_extend_back_end_encodeBetterBlockAsm4MB:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 4(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeBetterBlockAsm4MB
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeBetterBlockAsm4MB:
+        MOVL CX, SI
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), R9
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_match_nolit_encodeBetterBlockAsm4MB:
+        CMPL DI, $0x10
+        JB   matchlen_match8_match_nolit_encodeBetterBlockAsm4MB
+        MOVQ (R8)(R11*1), R10
+        MOVQ 8(R8)(R11*1), R12
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeBetterBlockAsm4MB
+        XORQ 8(R9)(R11*1), R12
+        JNZ  matchlen_bsf_16match_nolit_encodeBetterBlockAsm4MB
+        LEAL -16(DI), DI
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_match_nolit_encodeBetterBlockAsm4MB
+
+matchlen_bsf_16match_nolit_encodeBetterBlockAsm4MB:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  match_nolit_end_encodeBetterBlockAsm4MB
+
+matchlen_match8_match_nolit_encodeBetterBlockAsm4MB:
+        CMPL DI, $0x08
+        JB   matchlen_match4_match_nolit_encodeBetterBlockAsm4MB
+        MOVQ (R8)(R11*1), R10
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeBetterBlockAsm4MB
+        LEAL -8(DI), DI
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_match_nolit_encodeBetterBlockAsm4MB
+
+matchlen_bsf_8_match_nolit_encodeBetterBlockAsm4MB:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  match_nolit_end_encodeBetterBlockAsm4MB
+
+matchlen_match4_match_nolit_encodeBetterBlockAsm4MB:
+        CMPL DI, $0x04
+        JB   matchlen_match2_match_nolit_encodeBetterBlockAsm4MB
+        MOVL (R8)(R11*1), R10
+        CMPL (R9)(R11*1), R10
+        JNE  matchlen_match2_match_nolit_encodeBetterBlockAsm4MB
+        LEAL -4(DI), DI
+        LEAL 4(R11), R11
+
+matchlen_match2_match_nolit_encodeBetterBlockAsm4MB:
+        CMPL DI, $0x01
+        JE   matchlen_match1_match_nolit_encodeBetterBlockAsm4MB
+        JB   match_nolit_end_encodeBetterBlockAsm4MB
+        MOVW (R8)(R11*1), R10
+        CMPW (R9)(R11*1), R10
+        JNE  matchlen_match1_match_nolit_encodeBetterBlockAsm4MB
+        LEAL 2(R11), R11
+        SUBL $0x02, DI
+        JZ   match_nolit_end_encodeBetterBlockAsm4MB
+
+matchlen_match1_match_nolit_encodeBetterBlockAsm4MB:
+        MOVB (R8)(R11*1), R10
+        CMPB (R9)(R11*1), R10
+        JNE  match_nolit_end_encodeBetterBlockAsm4MB
+        LEAL 1(R11), R11
+
+match_nolit_end_encodeBetterBlockAsm4MB:
+        MOVL CX, DI
+        SUBL BX, DI
+
+        // Check if repeat
+        CMPL 16(SP), DI
+        JEQ  match_is_repeat_encodeBetterBlockAsm4MB
+        CMPL R11, $0x01
+        JA   match_length_ok_encodeBetterBlockAsm4MB
+        CMPL DI, $0x0000ffff
+        JBE  match_length_ok_encodeBetterBlockAsm4MB
+        MOVL 20(SP), CX
+        INCL CX
+        JMP  search_loop_encodeBetterBlockAsm4MB
+
+match_length_ok_encodeBetterBlockAsm4MB:
+        MOVL DI, 16(SP)
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_encodeBetterBlockAsm4MB
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_encodeBetterBlockAsm4MB
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_encodeBetterBlockAsm4MB
+        CMPL BX, $0x00010000
+        JB   three_bytes_match_emit_encodeBetterBlockAsm4MB
+        MOVL BX, R10
+        SHRL $0x10, R10
+        MOVB $0xf8, (AX)
+        MOVW BX, 1(AX)
+        MOVB R10, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_match_emit_encodeBetterBlockAsm4MB
+
+three_bytes_match_emit_encodeBetterBlockAsm4MB:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeBetterBlockAsm4MB
+
+two_bytes_match_emit_encodeBetterBlockAsm4MB:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_encodeBetterBlockAsm4MB
+        JMP  memmove_long_match_emit_encodeBetterBlockAsm4MB
+
+one_byte_match_emit_encodeBetterBlockAsm4MB:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeBetterBlockAsm4MB:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x04
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm4MB_memmove_move_4
+        CMPQ R8, $0x08
+        JB   emit_lit_memmove_match_emit_encodeBetterBlockAsm4MB_memmove_move_4through7
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm4MB_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm4MB_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeBetterBlockAsm4MB_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm4MB_memmove_move_4:
+        MOVL (R9), R10
+        MOVL R10, (AX)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm4MB
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm4MB_memmove_move_4through7:
+        MOVL (R9), R10
+        MOVL -4(R9)(R8*1), R9
+        MOVL R10, (AX)
+        MOVL R9, -4(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm4MB
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm4MB_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm4MB
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm4MB_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeBetterBlockAsm4MB
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm4MB_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeBetterBlockAsm4MB:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_encodeBetterBlockAsm4MB
+
+memmove_long_match_emit_encodeBetterBlockAsm4MB:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R13
+        SUBQ  R10, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_match_emit_encodeBetterBlockAsm4MBlarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R13*1), R10
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_match_emit_encodeBetterBlockAsm4MBlarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_match_emit_encodeBetterBlockAsm4MBlarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeBetterBlockAsm4MBlarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R13*1), X4
+        MOVOU -16(R9)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_match_emit_encodeBetterBlockAsm4MBlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_encodeBetterBlockAsm4MB:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitCopy
+        CMPL DI, $0x00010000
+        JB   two_byte_offset_match_nolit_encodeBetterBlockAsm4MB
+        CMPL R11, $0x40
+        JBE  four_bytes_remain_match_nolit_encodeBetterBlockAsm4MB
+        MOVB $0xff, (AX)
+        MOVL DI, 1(AX)
+        LEAL -64(R11), R11
+        ADDQ $0x05, AX
+        CMPL R11, $0x04
+        JB   four_bytes_remain_match_nolit_encodeBetterBlockAsm4MB
+
+        // emitRepeat
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_encodeBetterBlockAsm4MB_emit_copy
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm4MB_emit_copy
+        CMPL DI, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBetterBlockAsm4MB_emit_copy
+
+cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm4MB_emit_copy:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_encodeBetterBlockAsm4MB_emit_copy
+        CMPL R11, $0x00010100
+        JB   repeat_four_match_nolit_encodeBetterBlockAsm4MB_emit_copy
+        LEAL -65536(R11), R11
+        MOVL R11, DI
+        MOVW $0x001d, (AX)
+        MOVW R11, 2(AX)
+        SARL $0x10, DI
+        MOVB DI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_four_match_nolit_encodeBetterBlockAsm4MB_emit_copy:
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_three_match_nolit_encodeBetterBlockAsm4MB_emit_copy:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_two_match_nolit_encodeBetterBlockAsm4MB_emit_copy:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_two_offset_match_nolit_encodeBetterBlockAsm4MB_emit_copy:
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+four_bytes_remain_match_nolit_encodeBetterBlockAsm4MB:
+        TESTL R11, R11
+        JZ    match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+        XORL  BX, BX
+        LEAL  -1(BX)(R11*4), R11
+        MOVB  R11, (AX)
+        MOVL  DI, 1(AX)
+        ADDQ  $0x05, AX
+        JMP   match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+two_byte_offset_match_nolit_encodeBetterBlockAsm4MB:
+        CMPL R11, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeBetterBlockAsm4MB
+        CMPL DI, $0x00000800
+        JAE  long_offset_short_match_nolit_encodeBetterBlockAsm4MB
+        MOVL $0x00000001, BX
+        LEAL 16(BX), BX
+        MOVB DI, 1(AX)
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, R11
+
+        // emitRepeat
+        LEAL -4(R11), R11
+        JMP  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short_2b
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short_2b
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short_2b
+        CMPL DI, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short_2b
+
+cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short_2b:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short_2b
+        CMPL R11, $0x00010100
+        JB   repeat_four_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short_2b
+        LEAL -65536(R11), R11
+        MOVL R11, DI
+        MOVW $0x001d, (AX)
+        MOVW R11, 2(AX)
+        SARL $0x10, DI
+        MOVB DI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_four_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short_2b:
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_three_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short_2b:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_two_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short_2b:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_two_offset_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short_2b:
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+long_offset_short_match_nolit_encodeBetterBlockAsm4MB:
+        MOVB $0xee, (AX)
+        MOVW DI, 1(AX)
+        LEAL -60(R11), R11
+        ADDQ $0x03, AX
+
+        // emitRepeat
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short
+        CMPL DI, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short
+
+cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short
+        CMPL R11, $0x00010100
+        JB   repeat_four_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short
+        LEAL -65536(R11), R11
+        MOVL R11, DI
+        MOVW $0x001d, (AX)
+        MOVW R11, 2(AX)
+        SARL $0x10, DI
+        MOVB DI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_four_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short:
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_three_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_two_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_two_offset_match_nolit_encodeBetterBlockAsm4MB_emit_copy_short:
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+two_byte_offset_short_match_nolit_encodeBetterBlockAsm4MB:
+        MOVL R11, BX
+        SHLL $0x02, BX
+        CMPL R11, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeBetterBlockAsm4MB
+        CMPL DI, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeBetterBlockAsm4MB
+        LEAL -15(BX), BX
+        MOVB DI, 1(AX)
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+emit_copy_three_match_nolit_encodeBetterBlockAsm4MB:
+        LEAL -2(BX), BX
+        MOVB BL, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+match_is_repeat_encodeBetterBlockAsm4MB:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_repeat_encodeBetterBlockAsm4MB
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_repeat_encodeBetterBlockAsm4MB
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_repeat_encodeBetterBlockAsm4MB
+        CMPL BX, $0x00010000
+        JB   three_bytes_match_emit_repeat_encodeBetterBlockAsm4MB
+        MOVL BX, R10
+        SHRL $0x10, R10
+        MOVB $0xf8, (AX)
+        MOVW BX, 1(AX)
+        MOVB R10, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_match_emit_repeat_encodeBetterBlockAsm4MB
+
+three_bytes_match_emit_repeat_encodeBetterBlockAsm4MB:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_repeat_encodeBetterBlockAsm4MB
+
+two_bytes_match_emit_repeat_encodeBetterBlockAsm4MB:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_repeat_encodeBetterBlockAsm4MB
+        JMP  memmove_long_match_emit_repeat_encodeBetterBlockAsm4MB
+
+one_byte_match_emit_repeat_encodeBetterBlockAsm4MB:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_repeat_encodeBetterBlockAsm4MB:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x04
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm4MB_memmove_move_4
+        CMPQ R8, $0x08
+        JB   emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm4MB_memmove_move_4through7
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm4MB_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm4MB_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm4MB_memmove_move_33through64
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm4MB_memmove_move_4:
+        MOVL (R9), R10
+        MOVL R10, (AX)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm4MB
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm4MB_memmove_move_4through7:
+        MOVL (R9), R10
+        MOVL -4(R9)(R8*1), R9
+        MOVL R10, (AX)
+        MOVL R9, -4(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm4MB
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm4MB_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm4MB
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm4MB_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm4MB
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm4MB_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm4MB:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_repeat_encodeBetterBlockAsm4MB
+
+memmove_long_match_emit_repeat_encodeBetterBlockAsm4MB:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R13
+        SUBQ  R10, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm4MBlarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R13*1), R10
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm4MBlarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm4MBlarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm4MBlarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R13*1), X4
+        MOVOU -16(R9)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm4MBlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_repeat_encodeBetterBlockAsm4MB:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitRepeat
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_repeat_encodeBetterBlockAsm4MB
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm4MB
+        CMPL DI, $0x00000800
+        JB   repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm4MB
+
+cant_repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm4MB:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_repeat_encodeBetterBlockAsm4MB
+        CMPL R11, $0x00010100
+        JB   repeat_four_match_nolit_repeat_encodeBetterBlockAsm4MB
+        LEAL -65536(R11), R11
+        MOVL R11, DI
+        MOVW $0x001d, (AX)
+        MOVW R11, 2(AX)
+        SARL $0x10, DI
+        MOVB DI, 4(AX)
+        ADDQ $0x05, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_four_match_nolit_repeat_encodeBetterBlockAsm4MB:
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_three_match_nolit_repeat_encodeBetterBlockAsm4MB:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_two_match_nolit_repeat_encodeBetterBlockAsm4MB:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm4MB
+
+repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm4MB:
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+
+match_nolit_emitcopy_end_encodeBetterBlockAsm4MB:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeBetterBlockAsm4MB
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeBetterBlockAsm4MB
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeBetterBlockAsm4MB:
+        MOVQ  $0x00cf1bbcdcbfa563, BX
+        MOVQ  $0x9e3779b1, DI
+        LEAQ  1(SI), SI
+        LEAQ  -2(CX), R8
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  1(DX)(SI*1), R10
+        MOVQ  (DX)(R8*1), R11
+        MOVQ  1(DX)(R8*1), R12
+        SHLQ  $0x08, R9
+        IMULQ BX, R9
+        SHRQ  $0x2f, R9
+        SHLQ  $0x20, R10
+        IMULQ DI, R10
+        SHRQ  $0x32, R10
+        SHLQ  $0x08, R11
+        IMULQ BX, R11
+        SHRQ  $0x2f, R11
+        SHLQ  $0x20, R12
+        IMULQ DI, R12
+        SHRQ  $0x32, R12
+        LEAQ  1(SI), DI
+        LEAQ  1(R8), R13
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  R8, 24(SP)(R11*4)
+        MOVL  DI, 524312(SP)(R10*4)
+        MOVL  R13, 524312(SP)(R12*4)
+        LEAQ  1(R8)(SI*1), DI
+        SHRQ  $0x01, DI
+        ADDQ  $0x01, SI
+        SUBQ  $0x01, R8
+
+index_loop_encodeBetterBlockAsm4MB:
+        CMPQ  DI, R8
+        JAE   search_loop_encodeBetterBlockAsm4MB
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  (DX)(DI*1), R10
+        SHLQ  $0x08, R9
+        IMULQ BX, R9
+        SHRQ  $0x2f, R9
+        SHLQ  $0x08, R10
+        IMULQ BX, R10
+        SHRQ  $0x2f, R10
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  DI, 24(SP)(R10*4)
+        ADDQ  $0x02, SI
+        ADDQ  $0x02, DI
+        JMP   index_loop_encodeBetterBlockAsm4MB
+
+emit_remainder_encodeBetterBlockAsm4MB:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 4(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeBetterBlockAsm4MB
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeBetterBlockAsm4MB:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeBetterBlockAsm4MB
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeBetterBlockAsm4MB
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeBetterBlockAsm4MB
+        CMPL DX, $0x00010000
+        JB   three_bytes_emit_remainder_encodeBetterBlockAsm4MB
+        MOVL DX, BX
+        SHRL $0x10, BX
+        MOVB $0xf8, (AX)
+        MOVW DX, 1(AX)
+        MOVB BL, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_emit_remainder_encodeBetterBlockAsm4MB
+
+three_bytes_emit_remainder_encodeBetterBlockAsm4MB:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeBetterBlockAsm4MB
+
+two_bytes_emit_remainder_encodeBetterBlockAsm4MB:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeBetterBlockAsm4MB
+        JMP  memmove_long_emit_remainder_encodeBetterBlockAsm4MB
+
+one_byte_emit_remainder_encodeBetterBlockAsm4MB:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeBetterBlockAsm4MB:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm4MB_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm4MB_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm4MB_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm4MB_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm4MB_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm4MB_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm4MB_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm4MB
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm4MB_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm4MB
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm4MB_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm4MB
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm4MB_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm4MB
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm4MB_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeBetterBlockAsm4MB
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm4MB_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeBetterBlockAsm4MB:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeBetterBlockAsm4MB
+
+memmove_long_emit_remainder_encodeBetterBlockAsm4MB:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm4MBlarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm4MBlarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm4MBlarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm4MBlarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm4MBlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeBetterBlockAsm4MB:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeBetterBlockAsm12B(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeBetterBlockAsm12B(SB), $81944-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000280, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeBetterBlockAsm12B:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeBetterBlockAsm12B
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -6(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  $0x00000000, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeBetterBlockAsm12B:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x06, BX
+        LEAL  1(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeBetterBlockAsm12B
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  $0x9e3779b1, BX
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x32, R9
+        SHLQ  $0x20, R10
+        IMULQ BX, R10
+        SHRQ  $0x34, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  65560(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        MOVL  CX, 65560(SP)(R10*4)
+        MOVQ  (DX)(BX*1), R9
+        MOVQ  (DX)(DI*1), R10
+        CMPQ  R9, SI
+        JEQ   candidate_match_encodeBetterBlockAsm12B
+        CMPQ  R10, SI
+        JNE   no_short_found_encodeBetterBlockAsm12B
+        MOVL  DI, BX
+        JMP   candidate_match_encodeBetterBlockAsm12B
+
+no_short_found_encodeBetterBlockAsm12B:
+        CMPL R9, SI
+        JEQ  candidate_match_encodeBetterBlockAsm12B
+        CMPL R10, SI
+        JEQ  candidateS_match_encodeBetterBlockAsm12B
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeBetterBlockAsm12B
+
+candidateS_match_encodeBetterBlockAsm12B:
+        SHRQ  $0x08, SI
+        MOVQ  SI, R9
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x32, R9
+        MOVL  24(SP)(R9*4), BX
+        INCL  CX
+        MOVL  CX, 24(SP)(R9*4)
+        CMPL  (DX)(BX*1), SI
+        JEQ   candidate_match_encodeBetterBlockAsm12B
+        DECL  CX
+        MOVL  DI, BX
+
+candidate_match_encodeBetterBlockAsm12B:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeBetterBlockAsm12B
+
+match_extend_back_loop_encodeBetterBlockAsm12B:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeBetterBlockAsm12B
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeBetterBlockAsm12B
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeBetterBlockAsm12B
+        JMP  match_extend_back_loop_encodeBetterBlockAsm12B
+
+match_extend_back_end_encodeBetterBlockAsm12B:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeBetterBlockAsm12B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeBetterBlockAsm12B:
+        MOVL CX, SI
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), R9
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_match_nolit_encodeBetterBlockAsm12B:
+        CMPL DI, $0x10
+        JB   matchlen_match8_match_nolit_encodeBetterBlockAsm12B
+        MOVQ (R8)(R11*1), R10
+        MOVQ 8(R8)(R11*1), R12
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeBetterBlockAsm12B
+        XORQ 8(R9)(R11*1), R12
+        JNZ  matchlen_bsf_16match_nolit_encodeBetterBlockAsm12B
+        LEAL -16(DI), DI
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_match_nolit_encodeBetterBlockAsm12B
+
+matchlen_bsf_16match_nolit_encodeBetterBlockAsm12B:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  match_nolit_end_encodeBetterBlockAsm12B
+
+matchlen_match8_match_nolit_encodeBetterBlockAsm12B:
+        CMPL DI, $0x08
+        JB   matchlen_match4_match_nolit_encodeBetterBlockAsm12B
+        MOVQ (R8)(R11*1), R10
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeBetterBlockAsm12B
+        LEAL -8(DI), DI
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_match_nolit_encodeBetterBlockAsm12B
+
+matchlen_bsf_8_match_nolit_encodeBetterBlockAsm12B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  match_nolit_end_encodeBetterBlockAsm12B
+
+matchlen_match4_match_nolit_encodeBetterBlockAsm12B:
+        CMPL DI, $0x04
+        JB   matchlen_match2_match_nolit_encodeBetterBlockAsm12B
+        MOVL (R8)(R11*1), R10
+        CMPL (R9)(R11*1), R10
+        JNE  matchlen_match2_match_nolit_encodeBetterBlockAsm12B
+        LEAL -4(DI), DI
+        LEAL 4(R11), R11
+
+matchlen_match2_match_nolit_encodeBetterBlockAsm12B:
+        CMPL DI, $0x01
+        JE   matchlen_match1_match_nolit_encodeBetterBlockAsm12B
+        JB   match_nolit_end_encodeBetterBlockAsm12B
+        MOVW (R8)(R11*1), R10
+        CMPW (R9)(R11*1), R10
+        JNE  matchlen_match1_match_nolit_encodeBetterBlockAsm12B
+        LEAL 2(R11), R11
+        SUBL $0x02, DI
+        JZ   match_nolit_end_encodeBetterBlockAsm12B
+
+matchlen_match1_match_nolit_encodeBetterBlockAsm12B:
+        MOVB (R8)(R11*1), R10
+        CMPB (R9)(R11*1), R10
+        JNE  match_nolit_end_encodeBetterBlockAsm12B
+        LEAL 1(R11), R11
+
+match_nolit_end_encodeBetterBlockAsm12B:
+        MOVL CX, DI
+        SUBL BX, DI
+
+        // Check if repeat
+        CMPL 16(SP), DI
+        JEQ  match_is_repeat_encodeBetterBlockAsm12B
+        MOVL DI, 16(SP)
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_encodeBetterBlockAsm12B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_encodeBetterBlockAsm12B
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_encodeBetterBlockAsm12B
+        JB   three_bytes_match_emit_encodeBetterBlockAsm12B
+
+three_bytes_match_emit_encodeBetterBlockAsm12B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeBetterBlockAsm12B
+
+two_bytes_match_emit_encodeBetterBlockAsm12B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_encodeBetterBlockAsm12B
+        JMP  memmove_long_match_emit_encodeBetterBlockAsm12B
+
+one_byte_match_emit_encodeBetterBlockAsm12B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeBetterBlockAsm12B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x04
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm12B_memmove_move_4
+        CMPQ R8, $0x08
+        JB   emit_lit_memmove_match_emit_encodeBetterBlockAsm12B_memmove_move_4through7
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm12B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm12B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeBetterBlockAsm12B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm12B_memmove_move_4:
+        MOVL (R9), R10
+        MOVL R10, (AX)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm12B
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm12B_memmove_move_4through7:
+        MOVL (R9), R10
+        MOVL -4(R9)(R8*1), R9
+        MOVL R10, (AX)
+        MOVL R9, -4(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm12B
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm12B_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm12B
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm12B_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeBetterBlockAsm12B
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm12B_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeBetterBlockAsm12B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_encodeBetterBlockAsm12B
+
+memmove_long_match_emit_encodeBetterBlockAsm12B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R13
+        SUBQ  R10, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_match_emit_encodeBetterBlockAsm12Blarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R13*1), R10
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_match_emit_encodeBetterBlockAsm12Blarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_match_emit_encodeBetterBlockAsm12Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeBetterBlockAsm12Blarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R13*1), X4
+        MOVOU -16(R9)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_match_emit_encodeBetterBlockAsm12Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_encodeBetterBlockAsm12B:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitCopy
+        CMPL R11, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeBetterBlockAsm12B
+        CMPL DI, $0x00000800
+        JAE  long_offset_short_match_nolit_encodeBetterBlockAsm12B
+        MOVL $0x00000001, BX
+        LEAL 16(BX), BX
+        MOVB DI, 1(AX)
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, R11
+
+        // emitRepeat
+        LEAL -4(R11), R11
+        JMP  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm12B_emit_copy_short_2b
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_encodeBetterBlockAsm12B_emit_copy_short_2b
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm12B_emit_copy_short_2b
+        CMPL DI, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBetterBlockAsm12B_emit_copy_short_2b
+
+cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm12B_emit_copy_short_2b:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_encodeBetterBlockAsm12B_emit_copy_short_2b
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm12B
+
+repeat_three_match_nolit_encodeBetterBlockAsm12B_emit_copy_short_2b:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm12B
+
+repeat_two_match_nolit_encodeBetterBlockAsm12B_emit_copy_short_2b:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm12B
+
+repeat_two_offset_match_nolit_encodeBetterBlockAsm12B_emit_copy_short_2b:
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm12B
+
+long_offset_short_match_nolit_encodeBetterBlockAsm12B:
+        MOVB $0xee, (AX)
+        MOVW DI, 1(AX)
+        LEAL -60(R11), R11
+        ADDQ $0x03, AX
+
+        // emitRepeat
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_encodeBetterBlockAsm12B_emit_copy_short
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm12B_emit_copy_short
+        CMPL DI, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBetterBlockAsm12B_emit_copy_short
+
+cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm12B_emit_copy_short:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_encodeBetterBlockAsm12B_emit_copy_short
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm12B
+
+repeat_three_match_nolit_encodeBetterBlockAsm12B_emit_copy_short:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm12B
+
+repeat_two_match_nolit_encodeBetterBlockAsm12B_emit_copy_short:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm12B
+
+repeat_two_offset_match_nolit_encodeBetterBlockAsm12B_emit_copy_short:
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm12B
+
+two_byte_offset_short_match_nolit_encodeBetterBlockAsm12B:
+        MOVL R11, BX
+        SHLL $0x02, BX
+        CMPL R11, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeBetterBlockAsm12B
+        CMPL DI, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeBetterBlockAsm12B
+        LEAL -15(BX), BX
+        MOVB DI, 1(AX)
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm12B
+
+emit_copy_three_match_nolit_encodeBetterBlockAsm12B:
+        LEAL -2(BX), BX
+        MOVB BL, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm12B
+
+match_is_repeat_encodeBetterBlockAsm12B:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_repeat_encodeBetterBlockAsm12B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_repeat_encodeBetterBlockAsm12B
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_repeat_encodeBetterBlockAsm12B
+        JB   three_bytes_match_emit_repeat_encodeBetterBlockAsm12B
+
+three_bytes_match_emit_repeat_encodeBetterBlockAsm12B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_repeat_encodeBetterBlockAsm12B
+
+two_bytes_match_emit_repeat_encodeBetterBlockAsm12B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_repeat_encodeBetterBlockAsm12B
+        JMP  memmove_long_match_emit_repeat_encodeBetterBlockAsm12B
+
+one_byte_match_emit_repeat_encodeBetterBlockAsm12B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_repeat_encodeBetterBlockAsm12B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x04
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm12B_memmove_move_4
+        CMPQ R8, $0x08
+        JB   emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm12B_memmove_move_4through7
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm12B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm12B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm12B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm12B_memmove_move_4:
+        MOVL (R9), R10
+        MOVL R10, (AX)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm12B
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm12B_memmove_move_4through7:
+        MOVL (R9), R10
+        MOVL -4(R9)(R8*1), R9
+        MOVL R10, (AX)
+        MOVL R9, -4(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm12B
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm12B_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm12B
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm12B_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm12B
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm12B_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm12B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_repeat_encodeBetterBlockAsm12B
+
+memmove_long_match_emit_repeat_encodeBetterBlockAsm12B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R13
+        SUBQ  R10, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm12Blarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R13*1), R10
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm12Blarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm12Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm12Blarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R13*1), X4
+        MOVOU -16(R9)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm12Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_repeat_encodeBetterBlockAsm12B:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitRepeat
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_repeat_encodeBetterBlockAsm12B
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm12B
+        CMPL DI, $0x00000800
+        JB   repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm12B
+
+cant_repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm12B:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_repeat_encodeBetterBlockAsm12B
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm12B
+
+repeat_three_match_nolit_repeat_encodeBetterBlockAsm12B:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm12B
+
+repeat_two_match_nolit_repeat_encodeBetterBlockAsm12B:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm12B
+
+repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm12B:
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+
+match_nolit_emitcopy_end_encodeBetterBlockAsm12B:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeBetterBlockAsm12B
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeBetterBlockAsm12B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeBetterBlockAsm12B:
+        MOVQ  $0x0000cf1bbcdcbf9b, BX
+        MOVQ  $0x9e3779b1, DI
+        LEAQ  1(SI), SI
+        LEAQ  -2(CX), R8
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  1(DX)(SI*1), R10
+        MOVQ  (DX)(R8*1), R11
+        MOVQ  1(DX)(R8*1), R12
+        SHLQ  $0x10, R9
+        IMULQ BX, R9
+        SHRQ  $0x32, R9
+        SHLQ  $0x20, R10
+        IMULQ DI, R10
+        SHRQ  $0x34, R10
+        SHLQ  $0x10, R11
+        IMULQ BX, R11
+        SHRQ  $0x32, R11
+        SHLQ  $0x20, R12
+        IMULQ DI, R12
+        SHRQ  $0x34, R12
+        LEAQ  1(SI), DI
+        LEAQ  1(R8), R13
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  R8, 24(SP)(R11*4)
+        MOVL  DI, 65560(SP)(R10*4)
+        MOVL  R13, 65560(SP)(R12*4)
+        LEAQ  1(R8)(SI*1), DI
+        SHRQ  $0x01, DI
+        ADDQ  $0x01, SI
+        SUBQ  $0x01, R8
+
+index_loop_encodeBetterBlockAsm12B:
+        CMPQ  DI, R8
+        JAE   search_loop_encodeBetterBlockAsm12B
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  (DX)(DI*1), R10
+        SHLQ  $0x10, R9
+        IMULQ BX, R9
+        SHRQ  $0x32, R9
+        SHLQ  $0x10, R10
+        IMULQ BX, R10
+        SHRQ  $0x32, R10
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  DI, 24(SP)(R10*4)
+        ADDQ  $0x02, SI
+        ADDQ  $0x02, DI
+        JMP   index_loop_encodeBetterBlockAsm12B
+
+emit_remainder_encodeBetterBlockAsm12B:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeBetterBlockAsm12B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeBetterBlockAsm12B:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeBetterBlockAsm12B
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeBetterBlockAsm12B
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeBetterBlockAsm12B
+        JB   three_bytes_emit_remainder_encodeBetterBlockAsm12B
+
+three_bytes_emit_remainder_encodeBetterBlockAsm12B:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeBetterBlockAsm12B
+
+two_bytes_emit_remainder_encodeBetterBlockAsm12B:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeBetterBlockAsm12B
+        JMP  memmove_long_emit_remainder_encodeBetterBlockAsm12B
+
+one_byte_emit_remainder_encodeBetterBlockAsm12B:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeBetterBlockAsm12B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm12B_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm12B_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm12B_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm12B_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm12B_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm12B_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm12B_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm12B_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm12B_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm12B_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm12B_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeBetterBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm12B_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeBetterBlockAsm12B:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeBetterBlockAsm12B
+
+memmove_long_emit_remainder_encodeBetterBlockAsm12B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm12Blarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm12Blarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm12Blarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm12Blarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm12Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeBetterBlockAsm12B:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeBetterBlockAsm10B(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeBetterBlockAsm10B(SB), $20504-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x000000a0, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeBetterBlockAsm10B:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeBetterBlockAsm10B
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -6(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  $0x00000000, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeBetterBlockAsm10B:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x05, BX
+        LEAL  1(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeBetterBlockAsm10B
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  $0x9e3779b1, BX
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x34, R9
+        SHLQ  $0x20, R10
+        IMULQ BX, R10
+        SHRQ  $0x36, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  16408(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        MOVL  CX, 16408(SP)(R10*4)
+        MOVQ  (DX)(BX*1), R9
+        MOVQ  (DX)(DI*1), R10
+        CMPQ  R9, SI
+        JEQ   candidate_match_encodeBetterBlockAsm10B
+        CMPQ  R10, SI
+        JNE   no_short_found_encodeBetterBlockAsm10B
+        MOVL  DI, BX
+        JMP   candidate_match_encodeBetterBlockAsm10B
+
+no_short_found_encodeBetterBlockAsm10B:
+        CMPL R9, SI
+        JEQ  candidate_match_encodeBetterBlockAsm10B
+        CMPL R10, SI
+        JEQ  candidateS_match_encodeBetterBlockAsm10B
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeBetterBlockAsm10B
+
+candidateS_match_encodeBetterBlockAsm10B:
+        SHRQ  $0x08, SI
+        MOVQ  SI, R9
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x34, R9
+        MOVL  24(SP)(R9*4), BX
+        INCL  CX
+        MOVL  CX, 24(SP)(R9*4)
+        CMPL  (DX)(BX*1), SI
+        JEQ   candidate_match_encodeBetterBlockAsm10B
+        DECL  CX
+        MOVL  DI, BX
+
+candidate_match_encodeBetterBlockAsm10B:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeBetterBlockAsm10B
+
+match_extend_back_loop_encodeBetterBlockAsm10B:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeBetterBlockAsm10B
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeBetterBlockAsm10B
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeBetterBlockAsm10B
+        JMP  match_extend_back_loop_encodeBetterBlockAsm10B
+
+match_extend_back_end_encodeBetterBlockAsm10B:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeBetterBlockAsm10B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeBetterBlockAsm10B:
+        MOVL CX, SI
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), R9
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_match_nolit_encodeBetterBlockAsm10B:
+        CMPL DI, $0x10
+        JB   matchlen_match8_match_nolit_encodeBetterBlockAsm10B
+        MOVQ (R8)(R11*1), R10
+        MOVQ 8(R8)(R11*1), R12
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeBetterBlockAsm10B
+        XORQ 8(R9)(R11*1), R12
+        JNZ  matchlen_bsf_16match_nolit_encodeBetterBlockAsm10B
+        LEAL -16(DI), DI
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_match_nolit_encodeBetterBlockAsm10B
+
+matchlen_bsf_16match_nolit_encodeBetterBlockAsm10B:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  match_nolit_end_encodeBetterBlockAsm10B
+
+matchlen_match8_match_nolit_encodeBetterBlockAsm10B:
+        CMPL DI, $0x08
+        JB   matchlen_match4_match_nolit_encodeBetterBlockAsm10B
+        MOVQ (R8)(R11*1), R10
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeBetterBlockAsm10B
+        LEAL -8(DI), DI
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_match_nolit_encodeBetterBlockAsm10B
+
+matchlen_bsf_8_match_nolit_encodeBetterBlockAsm10B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  match_nolit_end_encodeBetterBlockAsm10B
+
+matchlen_match4_match_nolit_encodeBetterBlockAsm10B:
+        CMPL DI, $0x04
+        JB   matchlen_match2_match_nolit_encodeBetterBlockAsm10B
+        MOVL (R8)(R11*1), R10
+        CMPL (R9)(R11*1), R10
+        JNE  matchlen_match2_match_nolit_encodeBetterBlockAsm10B
+        LEAL -4(DI), DI
+        LEAL 4(R11), R11
+
+matchlen_match2_match_nolit_encodeBetterBlockAsm10B:
+        CMPL DI, $0x01
+        JE   matchlen_match1_match_nolit_encodeBetterBlockAsm10B
+        JB   match_nolit_end_encodeBetterBlockAsm10B
+        MOVW (R8)(R11*1), R10
+        CMPW (R9)(R11*1), R10
+        JNE  matchlen_match1_match_nolit_encodeBetterBlockAsm10B
+        LEAL 2(R11), R11
+        SUBL $0x02, DI
+        JZ   match_nolit_end_encodeBetterBlockAsm10B
+
+matchlen_match1_match_nolit_encodeBetterBlockAsm10B:
+        MOVB (R8)(R11*1), R10
+        CMPB (R9)(R11*1), R10
+        JNE  match_nolit_end_encodeBetterBlockAsm10B
+        LEAL 1(R11), R11
+
+match_nolit_end_encodeBetterBlockAsm10B:
+        MOVL CX, DI
+        SUBL BX, DI
+
+        // Check if repeat
+        CMPL 16(SP), DI
+        JEQ  match_is_repeat_encodeBetterBlockAsm10B
+        MOVL DI, 16(SP)
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_encodeBetterBlockAsm10B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_encodeBetterBlockAsm10B
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_encodeBetterBlockAsm10B
+        JB   three_bytes_match_emit_encodeBetterBlockAsm10B
+
+three_bytes_match_emit_encodeBetterBlockAsm10B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeBetterBlockAsm10B
+
+two_bytes_match_emit_encodeBetterBlockAsm10B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_encodeBetterBlockAsm10B
+        JMP  memmove_long_match_emit_encodeBetterBlockAsm10B
+
+one_byte_match_emit_encodeBetterBlockAsm10B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeBetterBlockAsm10B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x04
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm10B_memmove_move_4
+        CMPQ R8, $0x08
+        JB   emit_lit_memmove_match_emit_encodeBetterBlockAsm10B_memmove_move_4through7
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm10B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm10B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeBetterBlockAsm10B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm10B_memmove_move_4:
+        MOVL (R9), R10
+        MOVL R10, (AX)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm10B
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm10B_memmove_move_4through7:
+        MOVL (R9), R10
+        MOVL -4(R9)(R8*1), R9
+        MOVL R10, (AX)
+        MOVL R9, -4(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm10B
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm10B_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm10B
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm10B_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeBetterBlockAsm10B
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm10B_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeBetterBlockAsm10B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_encodeBetterBlockAsm10B
+
+memmove_long_match_emit_encodeBetterBlockAsm10B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R13
+        SUBQ  R10, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_match_emit_encodeBetterBlockAsm10Blarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R13*1), R10
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_match_emit_encodeBetterBlockAsm10Blarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_match_emit_encodeBetterBlockAsm10Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeBetterBlockAsm10Blarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R13*1), X4
+        MOVOU -16(R9)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_match_emit_encodeBetterBlockAsm10Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_encodeBetterBlockAsm10B:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitCopy
+        CMPL R11, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeBetterBlockAsm10B
+        CMPL DI, $0x00000800
+        JAE  long_offset_short_match_nolit_encodeBetterBlockAsm10B
+        MOVL $0x00000001, BX
+        LEAL 16(BX), BX
+        MOVB DI, 1(AX)
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, R11
+
+        // emitRepeat
+        LEAL -4(R11), R11
+        JMP  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm10B_emit_copy_short_2b
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_encodeBetterBlockAsm10B_emit_copy_short_2b
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm10B_emit_copy_short_2b
+        CMPL DI, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBetterBlockAsm10B_emit_copy_short_2b
+
+cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm10B_emit_copy_short_2b:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_encodeBetterBlockAsm10B_emit_copy_short_2b
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm10B
+
+repeat_three_match_nolit_encodeBetterBlockAsm10B_emit_copy_short_2b:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm10B
+
+repeat_two_match_nolit_encodeBetterBlockAsm10B_emit_copy_short_2b:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm10B
+
+repeat_two_offset_match_nolit_encodeBetterBlockAsm10B_emit_copy_short_2b:
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm10B
+
+long_offset_short_match_nolit_encodeBetterBlockAsm10B:
+        MOVB $0xee, (AX)
+        MOVW DI, 1(AX)
+        LEAL -60(R11), R11
+        ADDQ $0x03, AX
+
+        // emitRepeat
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_encodeBetterBlockAsm10B_emit_copy_short
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm10B_emit_copy_short
+        CMPL DI, $0x00000800
+        JB   repeat_two_offset_match_nolit_encodeBetterBlockAsm10B_emit_copy_short
+
+cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm10B_emit_copy_short:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_encodeBetterBlockAsm10B_emit_copy_short
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm10B
+
+repeat_three_match_nolit_encodeBetterBlockAsm10B_emit_copy_short:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm10B
+
+repeat_two_match_nolit_encodeBetterBlockAsm10B_emit_copy_short:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm10B
+
+repeat_two_offset_match_nolit_encodeBetterBlockAsm10B_emit_copy_short:
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm10B
+
+two_byte_offset_short_match_nolit_encodeBetterBlockAsm10B:
+        MOVL R11, BX
+        SHLL $0x02, BX
+        CMPL R11, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeBetterBlockAsm10B
+        CMPL DI, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeBetterBlockAsm10B
+        LEAL -15(BX), BX
+        MOVB DI, 1(AX)
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm10B
+
+emit_copy_three_match_nolit_encodeBetterBlockAsm10B:
+        LEAL -2(BX), BX
+        MOVB BL, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm10B
+
+match_is_repeat_encodeBetterBlockAsm10B:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_repeat_encodeBetterBlockAsm10B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_repeat_encodeBetterBlockAsm10B
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_repeat_encodeBetterBlockAsm10B
+        JB   three_bytes_match_emit_repeat_encodeBetterBlockAsm10B
+
+three_bytes_match_emit_repeat_encodeBetterBlockAsm10B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_repeat_encodeBetterBlockAsm10B
+
+two_bytes_match_emit_repeat_encodeBetterBlockAsm10B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_repeat_encodeBetterBlockAsm10B
+        JMP  memmove_long_match_emit_repeat_encodeBetterBlockAsm10B
+
+one_byte_match_emit_repeat_encodeBetterBlockAsm10B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_repeat_encodeBetterBlockAsm10B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x04
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm10B_memmove_move_4
+        CMPQ R8, $0x08
+        JB   emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm10B_memmove_move_4through7
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm10B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm10B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm10B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm10B_memmove_move_4:
+        MOVL (R9), R10
+        MOVL R10, (AX)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm10B
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm10B_memmove_move_4through7:
+        MOVL (R9), R10
+        MOVL -4(R9)(R8*1), R9
+        MOVL R10, (AX)
+        MOVL R9, -4(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm10B
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm10B_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm10B
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm10B_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm10B
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm10B_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm10B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_repeat_encodeBetterBlockAsm10B
+
+memmove_long_match_emit_repeat_encodeBetterBlockAsm10B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R13
+        SUBQ  R10, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm10Blarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R13*1), R10
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm10Blarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm10Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm10Blarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R13*1), X4
+        MOVOU -16(R9)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm10Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_repeat_encodeBetterBlockAsm10B:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitRepeat
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_repeat_encodeBetterBlockAsm10B
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm10B
+        CMPL DI, $0x00000800
+        JB   repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm10B
+
+cant_repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm10B:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_repeat_encodeBetterBlockAsm10B
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm10B
+
+repeat_three_match_nolit_repeat_encodeBetterBlockAsm10B:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm10B
+
+repeat_two_match_nolit_repeat_encodeBetterBlockAsm10B:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm10B
+
+repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm10B:
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+
+match_nolit_emitcopy_end_encodeBetterBlockAsm10B:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeBetterBlockAsm10B
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeBetterBlockAsm10B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeBetterBlockAsm10B:
+        MOVQ  $0x0000cf1bbcdcbf9b, BX
+        MOVQ  $0x9e3779b1, DI
+        LEAQ  1(SI), SI
+        LEAQ  -2(CX), R8
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  1(DX)(SI*1), R10
+        MOVQ  (DX)(R8*1), R11
+        MOVQ  1(DX)(R8*1), R12
+        SHLQ  $0x10, R9
+        IMULQ BX, R9
+        SHRQ  $0x34, R9
+        SHLQ  $0x20, R10
+        IMULQ DI, R10
+        SHRQ  $0x36, R10
+        SHLQ  $0x10, R11
+        IMULQ BX, R11
+        SHRQ  $0x34, R11
+        SHLQ  $0x20, R12
+        IMULQ DI, R12
+        SHRQ  $0x36, R12
+        LEAQ  1(SI), DI
+        LEAQ  1(R8), R13
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  R8, 24(SP)(R11*4)
+        MOVL  DI, 16408(SP)(R10*4)
+        MOVL  R13, 16408(SP)(R12*4)
+        LEAQ  1(R8)(SI*1), DI
+        SHRQ  $0x01, DI
+        ADDQ  $0x01, SI
+        SUBQ  $0x01, R8
+
+index_loop_encodeBetterBlockAsm10B:
+        CMPQ  DI, R8
+        JAE   search_loop_encodeBetterBlockAsm10B
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  (DX)(DI*1), R10
+        SHLQ  $0x10, R9
+        IMULQ BX, R9
+        SHRQ  $0x34, R9
+        SHLQ  $0x10, R10
+        IMULQ BX, R10
+        SHRQ  $0x34, R10
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  DI, 24(SP)(R10*4)
+        ADDQ  $0x02, SI
+        ADDQ  $0x02, DI
+        JMP   index_loop_encodeBetterBlockAsm10B
+
+emit_remainder_encodeBetterBlockAsm10B:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeBetterBlockAsm10B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeBetterBlockAsm10B:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeBetterBlockAsm10B
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeBetterBlockAsm10B
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeBetterBlockAsm10B
+        JB   three_bytes_emit_remainder_encodeBetterBlockAsm10B
+
+three_bytes_emit_remainder_encodeBetterBlockAsm10B:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeBetterBlockAsm10B
+
+two_bytes_emit_remainder_encodeBetterBlockAsm10B:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeBetterBlockAsm10B
+        JMP  memmove_long_emit_remainder_encodeBetterBlockAsm10B
+
+one_byte_emit_remainder_encodeBetterBlockAsm10B:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeBetterBlockAsm10B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm10B_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm10B_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm10B_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm10B_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm10B_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm10B_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm10B_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm10B_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm10B_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm10B_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm10B_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeBetterBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm10B_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeBetterBlockAsm10B:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeBetterBlockAsm10B
+
+memmove_long_emit_remainder_encodeBetterBlockAsm10B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm10Blarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm10Blarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm10Blarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm10Blarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm10Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeBetterBlockAsm10B:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeBetterBlockAsm8B(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeBetterBlockAsm8B(SB), $5144-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000028, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeBetterBlockAsm8B:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeBetterBlockAsm8B
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -6(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  $0x00000000, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeBetterBlockAsm8B:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x04, BX
+        LEAL  1(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeBetterBlockAsm8B
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  $0x9e3779b1, BX
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x36, R9
+        SHLQ  $0x20, R10
+        IMULQ BX, R10
+        SHRQ  $0x38, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  4120(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        MOVL  CX, 4120(SP)(R10*4)
+        MOVQ  (DX)(BX*1), R9
+        MOVQ  (DX)(DI*1), R10
+        CMPQ  R9, SI
+        JEQ   candidate_match_encodeBetterBlockAsm8B
+        CMPQ  R10, SI
+        JNE   no_short_found_encodeBetterBlockAsm8B
+        MOVL  DI, BX
+        JMP   candidate_match_encodeBetterBlockAsm8B
+
+no_short_found_encodeBetterBlockAsm8B:
+        CMPL R9, SI
+        JEQ  candidate_match_encodeBetterBlockAsm8B
+        CMPL R10, SI
+        JEQ  candidateS_match_encodeBetterBlockAsm8B
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeBetterBlockAsm8B
+
+candidateS_match_encodeBetterBlockAsm8B:
+        SHRQ  $0x08, SI
+        MOVQ  SI, R9
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x36, R9
+        MOVL  24(SP)(R9*4), BX
+        INCL  CX
+        MOVL  CX, 24(SP)(R9*4)
+        CMPL  (DX)(BX*1), SI
+        JEQ   candidate_match_encodeBetterBlockAsm8B
+        DECL  CX
+        MOVL  DI, BX
+
+candidate_match_encodeBetterBlockAsm8B:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeBetterBlockAsm8B
+
+match_extend_back_loop_encodeBetterBlockAsm8B:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeBetterBlockAsm8B
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeBetterBlockAsm8B
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeBetterBlockAsm8B
+        JMP  match_extend_back_loop_encodeBetterBlockAsm8B
+
+match_extend_back_end_encodeBetterBlockAsm8B:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeBetterBlockAsm8B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeBetterBlockAsm8B:
+        MOVL CX, SI
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), R9
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_match_nolit_encodeBetterBlockAsm8B:
+        CMPL DI, $0x10
+        JB   matchlen_match8_match_nolit_encodeBetterBlockAsm8B
+        MOVQ (R8)(R11*1), R10
+        MOVQ 8(R8)(R11*1), R12
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeBetterBlockAsm8B
+        XORQ 8(R9)(R11*1), R12
+        JNZ  matchlen_bsf_16match_nolit_encodeBetterBlockAsm8B
+        LEAL -16(DI), DI
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_match_nolit_encodeBetterBlockAsm8B
+
+matchlen_bsf_16match_nolit_encodeBetterBlockAsm8B:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  match_nolit_end_encodeBetterBlockAsm8B
+
+matchlen_match8_match_nolit_encodeBetterBlockAsm8B:
+        CMPL DI, $0x08
+        JB   matchlen_match4_match_nolit_encodeBetterBlockAsm8B
+        MOVQ (R8)(R11*1), R10
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeBetterBlockAsm8B
+        LEAL -8(DI), DI
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_match_nolit_encodeBetterBlockAsm8B
+
+matchlen_bsf_8_match_nolit_encodeBetterBlockAsm8B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  match_nolit_end_encodeBetterBlockAsm8B
+
+matchlen_match4_match_nolit_encodeBetterBlockAsm8B:
+        CMPL DI, $0x04
+        JB   matchlen_match2_match_nolit_encodeBetterBlockAsm8B
+        MOVL (R8)(R11*1), R10
+        CMPL (R9)(R11*1), R10
+        JNE  matchlen_match2_match_nolit_encodeBetterBlockAsm8B
+        LEAL -4(DI), DI
+        LEAL 4(R11), R11
+
+matchlen_match2_match_nolit_encodeBetterBlockAsm8B:
+        CMPL DI, $0x01
+        JE   matchlen_match1_match_nolit_encodeBetterBlockAsm8B
+        JB   match_nolit_end_encodeBetterBlockAsm8B
+        MOVW (R8)(R11*1), R10
+        CMPW (R9)(R11*1), R10
+        JNE  matchlen_match1_match_nolit_encodeBetterBlockAsm8B
+        LEAL 2(R11), R11
+        SUBL $0x02, DI
+        JZ   match_nolit_end_encodeBetterBlockAsm8B
+
+matchlen_match1_match_nolit_encodeBetterBlockAsm8B:
+        MOVB (R8)(R11*1), R10
+        CMPB (R9)(R11*1), R10
+        JNE  match_nolit_end_encodeBetterBlockAsm8B
+        LEAL 1(R11), R11
+
+match_nolit_end_encodeBetterBlockAsm8B:
+        MOVL CX, DI
+        SUBL BX, DI
+
+        // Check if repeat
+        CMPL 16(SP), DI
+        JEQ  match_is_repeat_encodeBetterBlockAsm8B
+        MOVL DI, 16(SP)
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_encodeBetterBlockAsm8B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_encodeBetterBlockAsm8B
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_encodeBetterBlockAsm8B
+        JB   three_bytes_match_emit_encodeBetterBlockAsm8B
+
+three_bytes_match_emit_encodeBetterBlockAsm8B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeBetterBlockAsm8B
+
+two_bytes_match_emit_encodeBetterBlockAsm8B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_encodeBetterBlockAsm8B
+        JMP  memmove_long_match_emit_encodeBetterBlockAsm8B
+
+one_byte_match_emit_encodeBetterBlockAsm8B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeBetterBlockAsm8B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x04
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm8B_memmove_move_4
+        CMPQ R8, $0x08
+        JB   emit_lit_memmove_match_emit_encodeBetterBlockAsm8B_memmove_move_4through7
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm8B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeBetterBlockAsm8B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeBetterBlockAsm8B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm8B_memmove_move_4:
+        MOVL (R9), R10
+        MOVL R10, (AX)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm8B
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm8B_memmove_move_4through7:
+        MOVL (R9), R10
+        MOVL -4(R9)(R8*1), R9
+        MOVL R10, (AX)
+        MOVL R9, -4(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm8B
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm8B_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeBetterBlockAsm8B
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm8B_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeBetterBlockAsm8B
+
+emit_lit_memmove_match_emit_encodeBetterBlockAsm8B_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeBetterBlockAsm8B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_encodeBetterBlockAsm8B
+
+memmove_long_match_emit_encodeBetterBlockAsm8B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R13
+        SUBQ  R10, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_match_emit_encodeBetterBlockAsm8Blarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R13*1), R10
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_match_emit_encodeBetterBlockAsm8Blarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_match_emit_encodeBetterBlockAsm8Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeBetterBlockAsm8Blarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R13*1), X4
+        MOVOU -16(R9)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_match_emit_encodeBetterBlockAsm8Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_encodeBetterBlockAsm8B:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitCopy
+        CMPL R11, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeBetterBlockAsm8B
+        CMPL DI, $0x00000800
+        JAE  long_offset_short_match_nolit_encodeBetterBlockAsm8B
+        MOVL $0x00000001, BX
+        LEAL 16(BX), BX
+        MOVB DI, 1(AX)
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, R11
+
+        // emitRepeat
+        LEAL -4(R11), R11
+        JMP  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm8B_emit_copy_short_2b
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_encodeBetterBlockAsm8B_emit_copy_short_2b
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm8B_emit_copy_short_2b
+
+cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm8B_emit_copy_short_2b:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_encodeBetterBlockAsm8B_emit_copy_short_2b
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm8B
+
+repeat_three_match_nolit_encodeBetterBlockAsm8B_emit_copy_short_2b:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm8B
+
+repeat_two_match_nolit_encodeBetterBlockAsm8B_emit_copy_short_2b:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm8B
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm8B
+
+long_offset_short_match_nolit_encodeBetterBlockAsm8B:
+        MOVB $0xee, (AX)
+        MOVW DI, 1(AX)
+        LEAL -60(R11), R11
+        ADDQ $0x03, AX
+
+        // emitRepeat
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_encodeBetterBlockAsm8B_emit_copy_short
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm8B_emit_copy_short
+
+cant_repeat_two_offset_match_nolit_encodeBetterBlockAsm8B_emit_copy_short:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_encodeBetterBlockAsm8B_emit_copy_short
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm8B
+
+repeat_three_match_nolit_encodeBetterBlockAsm8B_emit_copy_short:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm8B
+
+repeat_two_match_nolit_encodeBetterBlockAsm8B_emit_copy_short:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm8B
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm8B
+
+two_byte_offset_short_match_nolit_encodeBetterBlockAsm8B:
+        MOVL R11, BX
+        SHLL $0x02, BX
+        CMPL R11, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeBetterBlockAsm8B
+        LEAL -15(BX), BX
+        MOVB DI, 1(AX)
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm8B
+
+emit_copy_three_match_nolit_encodeBetterBlockAsm8B:
+        LEAL -2(BX), BX
+        MOVB BL, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm8B
+
+match_is_repeat_encodeBetterBlockAsm8B:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_repeat_encodeBetterBlockAsm8B
+        MOVL SI, DI
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R8
+        SUBL BX, DI
+        LEAL -1(DI), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_repeat_encodeBetterBlockAsm8B
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_repeat_encodeBetterBlockAsm8B
+        JB   three_bytes_match_emit_repeat_encodeBetterBlockAsm8B
+
+three_bytes_match_emit_repeat_encodeBetterBlockAsm8B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_repeat_encodeBetterBlockAsm8B
+
+two_bytes_match_emit_repeat_encodeBetterBlockAsm8B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_repeat_encodeBetterBlockAsm8B
+        JMP  memmove_long_match_emit_repeat_encodeBetterBlockAsm8B
+
+one_byte_match_emit_repeat_encodeBetterBlockAsm8B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_repeat_encodeBetterBlockAsm8B:
+        LEAQ (AX)(DI*1), BX
+
+        // genMemMoveShort
+        CMPQ DI, $0x04
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm8B_memmove_move_4
+        CMPQ DI, $0x08
+        JB   emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm8B_memmove_move_4through7
+        CMPQ DI, $0x10
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm8B_memmove_move_8through16
+        CMPQ DI, $0x20
+        JBE  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm8B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm8B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm8B_memmove_move_4:
+        MOVL (R8), R9
+        MOVL R9, (AX)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm8B
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm8B_memmove_move_4through7:
+        MOVL (R8), R9
+        MOVL -4(R8)(DI*1), R8
+        MOVL R9, (AX)
+        MOVL R8, -4(AX)(DI*1)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm8B
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm8B_memmove_move_8through16:
+        MOVQ (R8), R9
+        MOVQ -8(R8)(DI*1), R8
+        MOVQ R9, (AX)
+        MOVQ R8, -8(AX)(DI*1)
+        JMP  memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm8B
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm8B_memmove_move_17through32:
+        MOVOU (R8), X0
+        MOVOU -16(R8)(DI*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(DI*1)
+        JMP   memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm8B
+
+emit_lit_memmove_match_emit_repeat_encodeBetterBlockAsm8B_memmove_move_33through64:
+        MOVOU (R8), X0
+        MOVOU 16(R8), X1
+        MOVOU -32(R8)(DI*1), X2
+        MOVOU -16(R8)(DI*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(DI*1)
+        MOVOU X3, -16(AX)(DI*1)
+
+memmove_end_copy_match_emit_repeat_encodeBetterBlockAsm8B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_repeat_encodeBetterBlockAsm8B
+
+memmove_long_match_emit_repeat_encodeBetterBlockAsm8B:
+        LEAQ (AX)(DI*1), BX
+
+        // genMemMoveLong
+        MOVOU (R8), X0
+        MOVOU 16(R8), X1
+        MOVOU -32(R8)(DI*1), X2
+        MOVOU -16(R8)(DI*1), X3
+        MOVQ  DI, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R12
+        SUBQ  R9, R12
+        DECQ  R10
+        JA    emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm8Blarge_forward_sse_loop_32
+        LEAQ  -32(R8)(R12*1), R9
+        LEAQ  -32(AX)(R12*1), R13
+
+emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm8Blarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R13)
+        MOVOA X5, 16(R13)
+        ADDQ  $0x20, R13
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R12
+        DECQ  R10
+        JNA   emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm8Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm8Blarge_forward_sse_loop_32:
+        MOVOU -32(R8)(R12*1), X4
+        MOVOU -16(R8)(R12*1), X5
+        MOVOA X4, -32(AX)(R12*1)
+        MOVOA X5, -16(AX)(R12*1)
+        ADDQ  $0x20, R12
+        CMPQ  DI, R12
+        JAE   emit_lit_memmove_long_match_emit_repeat_encodeBetterBlockAsm8Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(DI*1)
+        MOVOU X3, -16(AX)(DI*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_repeat_encodeBetterBlockAsm8B:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitRepeat
+        MOVL R11, BX
+        LEAL -4(R11), R11
+        CMPL BX, $0x08
+        JBE  repeat_two_match_nolit_repeat_encodeBetterBlockAsm8B
+        CMPL BX, $0x0c
+        JAE  cant_repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm8B
+
+cant_repeat_two_offset_match_nolit_repeat_encodeBetterBlockAsm8B:
+        CMPL R11, $0x00000104
+        JB   repeat_three_match_nolit_repeat_encodeBetterBlockAsm8B
+        LEAL -256(R11), R11
+        MOVW $0x0019, (AX)
+        MOVW R11, 2(AX)
+        ADDQ $0x04, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm8B
+
+repeat_three_match_nolit_repeat_encodeBetterBlockAsm8B:
+        LEAL -4(R11), R11
+        MOVW $0x0015, (AX)
+        MOVB R11, 2(AX)
+        ADDQ $0x03, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm8B
+
+repeat_two_match_nolit_repeat_encodeBetterBlockAsm8B:
+        SHLL $0x02, R11
+        ORL  $0x01, R11
+        MOVW R11, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeBetterBlockAsm8B
+        XORQ BX, BX
+        LEAL 1(BX)(R11*4), R11
+        MOVB DI, 1(AX)
+        SARL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, R11
+        MOVB R11, (AX)
+        ADDQ $0x02, AX
+
+match_nolit_emitcopy_end_encodeBetterBlockAsm8B:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeBetterBlockAsm8B
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeBetterBlockAsm8B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeBetterBlockAsm8B:
+        MOVQ  $0x0000cf1bbcdcbf9b, BX
+        MOVQ  $0x9e3779b1, DI
+        LEAQ  1(SI), SI
+        LEAQ  -2(CX), R8
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  1(DX)(SI*1), R10
+        MOVQ  (DX)(R8*1), R11
+        MOVQ  1(DX)(R8*1), R12
+        SHLQ  $0x10, R9
+        IMULQ BX, R9
+        SHRQ  $0x36, R9
+        SHLQ  $0x20, R10
+        IMULQ DI, R10
+        SHRQ  $0x38, R10
+        SHLQ  $0x10, R11
+        IMULQ BX, R11
+        SHRQ  $0x36, R11
+        SHLQ  $0x20, R12
+        IMULQ DI, R12
+        SHRQ  $0x38, R12
+        LEAQ  1(SI), DI
+        LEAQ  1(R8), R13
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  R8, 24(SP)(R11*4)
+        MOVL  DI, 4120(SP)(R10*4)
+        MOVL  R13, 4120(SP)(R12*4)
+        LEAQ  1(R8)(SI*1), DI
+        SHRQ  $0x01, DI
+        ADDQ  $0x01, SI
+        SUBQ  $0x01, R8
+
+index_loop_encodeBetterBlockAsm8B:
+        CMPQ  DI, R8
+        JAE   search_loop_encodeBetterBlockAsm8B
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  (DX)(DI*1), R10
+        SHLQ  $0x10, R9
+        IMULQ BX, R9
+        SHRQ  $0x36, R9
+        SHLQ  $0x10, R10
+        IMULQ BX, R10
+        SHRQ  $0x36, R10
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  DI, 24(SP)(R10*4)
+        ADDQ  $0x02, SI
+        ADDQ  $0x02, DI
+        JMP   index_loop_encodeBetterBlockAsm8B
+
+emit_remainder_encodeBetterBlockAsm8B:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeBetterBlockAsm8B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeBetterBlockAsm8B:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeBetterBlockAsm8B
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeBetterBlockAsm8B
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeBetterBlockAsm8B
+        JB   three_bytes_emit_remainder_encodeBetterBlockAsm8B
+
+three_bytes_emit_remainder_encodeBetterBlockAsm8B:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeBetterBlockAsm8B
+
+two_bytes_emit_remainder_encodeBetterBlockAsm8B:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeBetterBlockAsm8B
+        JMP  memmove_long_emit_remainder_encodeBetterBlockAsm8B
+
+one_byte_emit_remainder_encodeBetterBlockAsm8B:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeBetterBlockAsm8B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm8B_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm8B_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeBetterBlockAsm8B_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm8B_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm8B_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeBetterBlockAsm8B_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm8B_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm8B_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm8B_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm8B_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeBetterBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm8B_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeBetterBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeBetterBlockAsm8B_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeBetterBlockAsm8B:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeBetterBlockAsm8B
+
+memmove_long_emit_remainder_encodeBetterBlockAsm8B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm8Blarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm8Blarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm8Blarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm8Blarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeBetterBlockAsm8Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeBetterBlockAsm8B:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeSnappyBlockAsm(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeSnappyBlockAsm(SB), $65560-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000200, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeSnappyBlockAsm:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeSnappyBlockAsm
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  CX, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeSnappyBlockAsm:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x06, BX
+        LEAL  4(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeSnappyBlockAsm
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHRQ  $0x08, R10
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x32, R9
+        SHLQ  $0x10, R10
+        IMULQ R8, R10
+        SHRQ  $0x32, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  24(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        LEAL  1(CX), R9
+        MOVL  R9, 24(SP)(R10*4)
+        MOVQ  SI, R9
+        SHRQ  $0x10, R9
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x32, R9
+        MOVL  CX, R8
+        SUBL  16(SP), R8
+        MOVL  1(DX)(R8*1), R10
+        MOVQ  SI, R8
+        SHRQ  $0x08, R8
+        CMPL  R8, R10
+        JNE   no_repeat_found_encodeSnappyBlockAsm
+        LEAL  1(CX), SI
+        MOVL  12(SP), BX
+        MOVL  SI, DI
+        SUBL  16(SP), DI
+        JZ    repeat_extend_back_end_encodeSnappyBlockAsm
+
+repeat_extend_back_loop_encodeSnappyBlockAsm:
+        CMPL SI, BX
+        JBE  repeat_extend_back_end_encodeSnappyBlockAsm
+        MOVB -1(DX)(DI*1), R8
+        MOVB -1(DX)(SI*1), R9
+        CMPB R8, R9
+        JNE  repeat_extend_back_end_encodeSnappyBlockAsm
+        LEAL -1(SI), SI
+        DECL DI
+        JNZ  repeat_extend_back_loop_encodeSnappyBlockAsm
+
+repeat_extend_back_end_encodeSnappyBlockAsm:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_repeat_emit_encodeSnappyBlockAsm
+        MOVL SI, DI
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R8
+        SUBL BX, DI
+        LEAL -1(DI), BX
+        CMPL BX, $0x3c
+        JB   one_byte_repeat_emit_encodeSnappyBlockAsm
+        CMPL BX, $0x00000100
+        JB   two_bytes_repeat_emit_encodeSnappyBlockAsm
+        CMPL BX, $0x00010000
+        JB   three_bytes_repeat_emit_encodeSnappyBlockAsm
+        CMPL BX, $0x01000000
+        JB   four_bytes_repeat_emit_encodeSnappyBlockAsm
+        MOVB $0xfc, (AX)
+        MOVL BX, 1(AX)
+        ADDQ $0x05, AX
+        JMP  memmove_long_repeat_emit_encodeSnappyBlockAsm
+
+four_bytes_repeat_emit_encodeSnappyBlockAsm:
+        MOVL BX, R9
+        SHRL $0x10, R9
+        MOVB $0xf8, (AX)
+        MOVW BX, 1(AX)
+        MOVB R9, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_repeat_emit_encodeSnappyBlockAsm
+
+three_bytes_repeat_emit_encodeSnappyBlockAsm:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_repeat_emit_encodeSnappyBlockAsm
+
+two_bytes_repeat_emit_encodeSnappyBlockAsm:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_repeat_emit_encodeSnappyBlockAsm
+        JMP  memmove_long_repeat_emit_encodeSnappyBlockAsm
+
+one_byte_repeat_emit_encodeSnappyBlockAsm:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_repeat_emit_encodeSnappyBlockAsm:
+        LEAQ (AX)(DI*1), BX
+
+        // genMemMoveShort
+        CMPQ DI, $0x08
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm_memmove_move_8
+        CMPQ DI, $0x10
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm_memmove_move_8through16
+        CMPQ DI, $0x20
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm_memmove_move_17through32
+        JMP  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm_memmove_move_33through64
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm_memmove_move_8:
+        MOVQ (R8), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_repeat_emit_encodeSnappyBlockAsm
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm_memmove_move_8through16:
+        MOVQ (R8), R9
+        MOVQ -8(R8)(DI*1), R8
+        MOVQ R9, (AX)
+        MOVQ R8, -8(AX)(DI*1)
+        JMP  memmove_end_copy_repeat_emit_encodeSnappyBlockAsm
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm_memmove_move_17through32:
+        MOVOU (R8), X0
+        MOVOU -16(R8)(DI*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(DI*1)
+        JMP   memmove_end_copy_repeat_emit_encodeSnappyBlockAsm
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm_memmove_move_33through64:
+        MOVOU (R8), X0
+        MOVOU 16(R8), X1
+        MOVOU -32(R8)(DI*1), X2
+        MOVOU -16(R8)(DI*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(DI*1)
+        MOVOU X3, -16(AX)(DI*1)
+
+memmove_end_copy_repeat_emit_encodeSnappyBlockAsm:
+        MOVQ BX, AX
+        JMP  emit_literal_done_repeat_emit_encodeSnappyBlockAsm
+
+memmove_long_repeat_emit_encodeSnappyBlockAsm:
+        LEAQ (AX)(DI*1), BX
+
+        // genMemMoveLong
+        MOVOU (R8), X0
+        MOVOU 16(R8), X1
+        MOVOU -32(R8)(DI*1), X2
+        MOVOU -16(R8)(DI*1), X3
+        MOVQ  DI, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsmlarge_forward_sse_loop_32
+        LEAQ  -32(R8)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsmlarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsmlarge_big_loop_back
+
+emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsmlarge_forward_sse_loop_32:
+        MOVOU -32(R8)(R11*1), X4
+        MOVOU -16(R8)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  DI, R11
+        JAE   emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsmlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(DI*1)
+        MOVOU X3, -16(AX)(DI*1)
+        MOVQ  BX, AX
+
+emit_literal_done_repeat_emit_encodeSnappyBlockAsm:
+        ADDL $0x05, CX
+        MOVL CX, BX
+        SUBL 16(SP), BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R10, R10
+
+matchlen_loopback_16_repeat_extend_encodeSnappyBlockAsm:
+        CMPL DI, $0x10
+        JB   matchlen_match8_repeat_extend_encodeSnappyBlockAsm
+        MOVQ (R8)(R10*1), R9
+        MOVQ 8(R8)(R10*1), R11
+        XORQ (BX)(R10*1), R9
+        JNZ  matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm
+        XORQ 8(BX)(R10*1), R11
+        JNZ  matchlen_bsf_16repeat_extend_encodeSnappyBlockAsm
+        LEAL -16(DI), DI
+        LEAL 16(R10), R10
+        JMP  matchlen_loopback_16_repeat_extend_encodeSnappyBlockAsm
+
+matchlen_bsf_16repeat_extend_encodeSnappyBlockAsm:
+#ifdef GOAMD64_v3
+        TZCNTQ R11, R11
+
+#else
+        BSFQ R11, R11
+
+#endif
+        SARQ $0x03, R11
+        LEAL 8(R10)(R11*1), R10
+        JMP  repeat_extend_forward_end_encodeSnappyBlockAsm
+
+matchlen_match8_repeat_extend_encodeSnappyBlockAsm:
+        CMPL DI, $0x08
+        JB   matchlen_match4_repeat_extend_encodeSnappyBlockAsm
+        MOVQ (R8)(R10*1), R9
+        XORQ (BX)(R10*1), R9
+        JNZ  matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm
+        LEAL -8(DI), DI
+        LEAL 8(R10), R10
+        JMP  matchlen_match4_repeat_extend_encodeSnappyBlockAsm
+
+matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm:
+#ifdef GOAMD64_v3
+        TZCNTQ R9, R9
+
+#else
+        BSFQ R9, R9
+
+#endif
+        SARQ $0x03, R9
+        LEAL (R10)(R9*1), R10
+        JMP  repeat_extend_forward_end_encodeSnappyBlockAsm
+
+matchlen_match4_repeat_extend_encodeSnappyBlockAsm:
+        CMPL DI, $0x04
+        JB   matchlen_match2_repeat_extend_encodeSnappyBlockAsm
+        MOVL (R8)(R10*1), R9
+        CMPL (BX)(R10*1), R9
+        JNE  matchlen_match2_repeat_extend_encodeSnappyBlockAsm
+        LEAL -4(DI), DI
+        LEAL 4(R10), R10
+
+matchlen_match2_repeat_extend_encodeSnappyBlockAsm:
+        CMPL DI, $0x01
+        JE   matchlen_match1_repeat_extend_encodeSnappyBlockAsm
+        JB   repeat_extend_forward_end_encodeSnappyBlockAsm
+        MOVW (R8)(R10*1), R9
+        CMPW (BX)(R10*1), R9
+        JNE  matchlen_match1_repeat_extend_encodeSnappyBlockAsm
+        LEAL 2(R10), R10
+        SUBL $0x02, DI
+        JZ   repeat_extend_forward_end_encodeSnappyBlockAsm
+
+matchlen_match1_repeat_extend_encodeSnappyBlockAsm:
+        MOVB (R8)(R10*1), R9
+        CMPB (BX)(R10*1), R9
+        JNE  repeat_extend_forward_end_encodeSnappyBlockAsm
+        LEAL 1(R10), R10
+
+repeat_extend_forward_end_encodeSnappyBlockAsm:
+        ADDL R10, CX
+        MOVL CX, BX
+        SUBL SI, BX
+        MOVL 16(SP), SI
+
+        // emitCopy
+        CMPL SI, $0x00010000
+        JB   two_byte_offset_repeat_as_copy_encodeSnappyBlockAsm
+
+four_bytes_loop_back_repeat_as_copy_encodeSnappyBlockAsm:
+        CMPL BX, $0x40
+        JBE  four_bytes_remain_repeat_as_copy_encodeSnappyBlockAsm
+        MOVB $0xff, (AX)
+        MOVL SI, 1(AX)
+        LEAL -64(BX), BX
+        ADDQ $0x05, AX
+        CMPL BX, $0x04
+        JB   four_bytes_remain_repeat_as_copy_encodeSnappyBlockAsm
+        JMP  four_bytes_loop_back_repeat_as_copy_encodeSnappyBlockAsm
+
+four_bytes_remain_repeat_as_copy_encodeSnappyBlockAsm:
+        TESTL BX, BX
+        JZ    repeat_end_emit_encodeSnappyBlockAsm
+        XORL  DI, DI
+        LEAL  -1(DI)(BX*4), BX
+        MOVB  BL, (AX)
+        MOVL  SI, 1(AX)
+        ADDQ  $0x05, AX
+        JMP   repeat_end_emit_encodeSnappyBlockAsm
+
+two_byte_offset_repeat_as_copy_encodeSnappyBlockAsm:
+        CMPL BX, $0x40
+        JBE  two_byte_offset_short_repeat_as_copy_encodeSnappyBlockAsm
+        MOVB $0xee, (AX)
+        MOVW SI, 1(AX)
+        LEAL -60(BX), BX
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_repeat_as_copy_encodeSnappyBlockAsm
+
+two_byte_offset_short_repeat_as_copy_encodeSnappyBlockAsm:
+        MOVL BX, DI
+        SHLL $0x02, DI
+        CMPL BX, $0x0c
+        JAE  emit_copy_three_repeat_as_copy_encodeSnappyBlockAsm
+        CMPL SI, $0x00000800
+        JAE  emit_copy_three_repeat_as_copy_encodeSnappyBlockAsm
+        LEAL -15(DI), DI
+        MOVB SI, 1(AX)
+        SHRL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeSnappyBlockAsm
+
+emit_copy_three_repeat_as_copy_encodeSnappyBlockAsm:
+        LEAL -2(DI), DI
+        MOVB DI, (AX)
+        MOVW SI, 1(AX)
+        ADDQ $0x03, AX
+
+repeat_end_emit_encodeSnappyBlockAsm:
+        MOVL CX, 12(SP)
+        JMP  search_loop_encodeSnappyBlockAsm
+
+no_repeat_found_encodeSnappyBlockAsm:
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate_match_encodeSnappyBlockAsm
+        SHRQ $0x08, SI
+        MOVL 24(SP)(R9*4), BX
+        LEAL 2(CX), R8
+        CMPL (DX)(DI*1), SI
+        JEQ  candidate2_match_encodeSnappyBlockAsm
+        MOVL R8, 24(SP)(R9*4)
+        SHRQ $0x08, SI
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate3_match_encodeSnappyBlockAsm
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeSnappyBlockAsm
+
+candidate3_match_encodeSnappyBlockAsm:
+        ADDL $0x02, CX
+        JMP  candidate_match_encodeSnappyBlockAsm
+
+candidate2_match_encodeSnappyBlockAsm:
+        MOVL R8, 24(SP)(R9*4)
+        INCL CX
+        MOVL DI, BX
+
+candidate_match_encodeSnappyBlockAsm:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeSnappyBlockAsm
+
+match_extend_back_loop_encodeSnappyBlockAsm:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeSnappyBlockAsm
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeSnappyBlockAsm
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeSnappyBlockAsm
+        JMP  match_extend_back_loop_encodeSnappyBlockAsm
+
+match_extend_back_end_encodeSnappyBlockAsm:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 5(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeSnappyBlockAsm
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeSnappyBlockAsm:
+        MOVL CX, SI
+        MOVL 12(SP), DI
+        CMPL DI, SI
+        JEQ  emit_literal_done_match_emit_encodeSnappyBlockAsm
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(DI*1), SI
+        SUBL DI, R8
+        LEAL -1(R8), DI
+        CMPL DI, $0x3c
+        JB   one_byte_match_emit_encodeSnappyBlockAsm
+        CMPL DI, $0x00000100
+        JB   two_bytes_match_emit_encodeSnappyBlockAsm
+        CMPL DI, $0x00010000
+        JB   three_bytes_match_emit_encodeSnappyBlockAsm
+        CMPL DI, $0x01000000
+        JB   four_bytes_match_emit_encodeSnappyBlockAsm
+        MOVB $0xfc, (AX)
+        MOVL DI, 1(AX)
+        ADDQ $0x05, AX
+        JMP  memmove_long_match_emit_encodeSnappyBlockAsm
+
+four_bytes_match_emit_encodeSnappyBlockAsm:
+        MOVL DI, R9
+        SHRL $0x10, R9
+        MOVB $0xf8, (AX)
+        MOVW DI, 1(AX)
+        MOVB R9, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_match_emit_encodeSnappyBlockAsm
+
+three_bytes_match_emit_encodeSnappyBlockAsm:
+        MOVB $0xf4, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeSnappyBlockAsm
+
+two_bytes_match_emit_encodeSnappyBlockAsm:
+        MOVB $0xf0, (AX)
+        MOVB DI, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DI, $0x40
+        JB   memmove_match_emit_encodeSnappyBlockAsm
+        JMP  memmove_long_match_emit_encodeSnappyBlockAsm
+
+one_byte_match_emit_encodeSnappyBlockAsm:
+        SHLB $0x02, DI
+        MOVB DI, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeSnappyBlockAsm:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeSnappyBlockAsm_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm_memmove_move_8:
+        MOVQ (SI), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBlockAsm
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm_memmove_move_8through16:
+        MOVQ (SI), R9
+        MOVQ -8(SI)(R8*1), SI
+        MOVQ R9, (AX)
+        MOVQ SI, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBlockAsm
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm_memmove_move_17through32:
+        MOVOU (SI), X0
+        MOVOU -16(SI)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeSnappyBlockAsm
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm_memmove_move_33through64:
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeSnappyBlockAsm:
+        MOVQ DI, AX
+        JMP  emit_literal_done_match_emit_encodeSnappyBlockAsm
+
+memmove_long_match_emit_encodeSnappyBlockAsm:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveLong
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVQ  R8, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_match_emit_encodeSnappyBlockAsmlarge_forward_sse_loop_32
+        LEAQ  -32(SI)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_match_emit_encodeSnappyBlockAsmlarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_match_emit_encodeSnappyBlockAsmlarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeSnappyBlockAsmlarge_forward_sse_loop_32:
+        MOVOU -32(SI)(R11*1), X4
+        MOVOU -16(SI)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  R8, R11
+        JAE   emit_lit_memmove_long_match_emit_encodeSnappyBlockAsmlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  DI, AX
+
+emit_literal_done_match_emit_encodeSnappyBlockAsm:
+match_nolit_loop_encodeSnappyBlockAsm:
+        MOVL CX, SI
+        SUBL BX, SI
+        MOVL SI, 16(SP)
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), SI
+        SUBL CX, SI
+        LEAQ (DX)(CX*1), DI
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R9, R9
+
+matchlen_loopback_16_match_nolit_encodeSnappyBlockAsm:
+        CMPL SI, $0x10
+        JB   matchlen_match8_match_nolit_encodeSnappyBlockAsm
+        MOVQ (DI)(R9*1), R8
+        MOVQ 8(DI)(R9*1), R10
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm
+        XORQ 8(BX)(R9*1), R10
+        JNZ  matchlen_bsf_16match_nolit_encodeSnappyBlockAsm
+        LEAL -16(SI), SI
+        LEAL 16(R9), R9
+        JMP  matchlen_loopback_16_match_nolit_encodeSnappyBlockAsm
+
+matchlen_bsf_16match_nolit_encodeSnappyBlockAsm:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL 8(R9)(R10*1), R9
+        JMP  match_nolit_end_encodeSnappyBlockAsm
+
+matchlen_match8_match_nolit_encodeSnappyBlockAsm:
+        CMPL SI, $0x08
+        JB   matchlen_match4_match_nolit_encodeSnappyBlockAsm
+        MOVQ (DI)(R9*1), R8
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm
+        LEAL -8(SI), SI
+        LEAL 8(R9), R9
+        JMP  matchlen_match4_match_nolit_encodeSnappyBlockAsm
+
+matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm:
+#ifdef GOAMD64_v3
+        TZCNTQ R8, R8
+
+#else
+        BSFQ R8, R8
+
+#endif
+        SARQ $0x03, R8
+        LEAL (R9)(R8*1), R9
+        JMP  match_nolit_end_encodeSnappyBlockAsm
+
+matchlen_match4_match_nolit_encodeSnappyBlockAsm:
+        CMPL SI, $0x04
+        JB   matchlen_match2_match_nolit_encodeSnappyBlockAsm
+        MOVL (DI)(R9*1), R8
+        CMPL (BX)(R9*1), R8
+        JNE  matchlen_match2_match_nolit_encodeSnappyBlockAsm
+        LEAL -4(SI), SI
+        LEAL 4(R9), R9
+
+matchlen_match2_match_nolit_encodeSnappyBlockAsm:
+        CMPL SI, $0x01
+        JE   matchlen_match1_match_nolit_encodeSnappyBlockAsm
+        JB   match_nolit_end_encodeSnappyBlockAsm
+        MOVW (DI)(R9*1), R8
+        CMPW (BX)(R9*1), R8
+        JNE  matchlen_match1_match_nolit_encodeSnappyBlockAsm
+        LEAL 2(R9), R9
+        SUBL $0x02, SI
+        JZ   match_nolit_end_encodeSnappyBlockAsm
+
+matchlen_match1_match_nolit_encodeSnappyBlockAsm:
+        MOVB (DI)(R9*1), R8
+        CMPB (BX)(R9*1), R8
+        JNE  match_nolit_end_encodeSnappyBlockAsm
+        LEAL 1(R9), R9
+
+match_nolit_end_encodeSnappyBlockAsm:
+        ADDL R9, CX
+        MOVL 16(SP), BX
+        ADDL $0x04, R9
+        MOVL CX, 12(SP)
+
+        // emitCopy
+        CMPL BX, $0x00010000
+        JB   two_byte_offset_match_nolit_encodeSnappyBlockAsm
+
+four_bytes_loop_back_match_nolit_encodeSnappyBlockAsm:
+        CMPL R9, $0x40
+        JBE  four_bytes_remain_match_nolit_encodeSnappyBlockAsm
+        MOVB $0xff, (AX)
+        MOVL BX, 1(AX)
+        LEAL -64(R9), R9
+        ADDQ $0x05, AX
+        CMPL R9, $0x04
+        JB   four_bytes_remain_match_nolit_encodeSnappyBlockAsm
+        JMP  four_bytes_loop_back_match_nolit_encodeSnappyBlockAsm
+
+four_bytes_remain_match_nolit_encodeSnappyBlockAsm:
+        TESTL R9, R9
+        JZ    match_nolit_emitcopy_end_encodeSnappyBlockAsm
+        XORL  SI, SI
+        LEAL  -1(SI)(R9*4), R9
+        MOVB  R9, (AX)
+        MOVL  BX, 1(AX)
+        ADDQ  $0x05, AX
+        JMP   match_nolit_emitcopy_end_encodeSnappyBlockAsm
+
+two_byte_offset_match_nolit_encodeSnappyBlockAsm:
+        CMPL R9, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeSnappyBlockAsm
+        MOVB $0xee, (AX)
+        MOVW BX, 1(AX)
+        LEAL -60(R9), R9
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_match_nolit_encodeSnappyBlockAsm
+
+two_byte_offset_short_match_nolit_encodeSnappyBlockAsm:
+        MOVL R9, SI
+        SHLL $0x02, SI
+        CMPL R9, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeSnappyBlockAsm
+        CMPL BX, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeSnappyBlockAsm
+        LEAL -15(SI), SI
+        MOVB BL, 1(AX)
+        SHRL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeSnappyBlockAsm
+
+emit_copy_three_match_nolit_encodeSnappyBlockAsm:
+        LEAL -2(SI), SI
+        MOVB SI, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeSnappyBlockAsm:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeSnappyBlockAsm
+        MOVQ -2(DX)(CX*1), SI
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeSnappyBlockAsm
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeSnappyBlockAsm:
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  SI, DI
+        SHRQ  $0x10, SI
+        MOVQ  SI, BX
+        SHLQ  $0x10, DI
+        IMULQ R8, DI
+        SHRQ  $0x32, DI
+        SHLQ  $0x10, BX
+        IMULQ R8, BX
+        SHRQ  $0x32, BX
+        LEAL  -2(CX), R8
+        LEAQ  24(SP)(BX*4), R9
+        MOVL  (R9), BX
+        MOVL  R8, 24(SP)(DI*4)
+        MOVL  CX, (R9)
+        CMPL  (DX)(BX*1), SI
+        JEQ   match_nolit_loop_encodeSnappyBlockAsm
+        INCL  CX
+        JMP   search_loop_encodeSnappyBlockAsm
+
+emit_remainder_encodeSnappyBlockAsm:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 5(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeSnappyBlockAsm
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeSnappyBlockAsm:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeSnappyBlockAsm
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeSnappyBlockAsm
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeSnappyBlockAsm
+        CMPL DX, $0x00010000
+        JB   three_bytes_emit_remainder_encodeSnappyBlockAsm
+        CMPL DX, $0x01000000
+        JB   four_bytes_emit_remainder_encodeSnappyBlockAsm
+        MOVB $0xfc, (AX)
+        MOVL DX, 1(AX)
+        ADDQ $0x05, AX
+        JMP  memmove_long_emit_remainder_encodeSnappyBlockAsm
+
+four_bytes_emit_remainder_encodeSnappyBlockAsm:
+        MOVL DX, BX
+        SHRL $0x10, BX
+        MOVB $0xf8, (AX)
+        MOVW DX, 1(AX)
+        MOVB BL, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_emit_remainder_encodeSnappyBlockAsm
+
+three_bytes_emit_remainder_encodeSnappyBlockAsm:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeSnappyBlockAsm
+
+two_bytes_emit_remainder_encodeSnappyBlockAsm:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeSnappyBlockAsm
+        JMP  memmove_long_emit_remainder_encodeSnappyBlockAsm
+
+one_byte_emit_remainder_encodeSnappyBlockAsm:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeSnappyBlockAsm:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeSnappyBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeSnappyBlockAsm:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeSnappyBlockAsm
+
+memmove_long_emit_remainder_encodeSnappyBlockAsm:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsmlarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsmlarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsmlarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsmlarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsmlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeSnappyBlockAsm:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeSnappyBlockAsm64K(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeSnappyBlockAsm64K(SB), $65560-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000200, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeSnappyBlockAsm64K:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeSnappyBlockAsm64K
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  CX, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeSnappyBlockAsm64K:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x06, BX
+        LEAL  4(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeSnappyBlockAsm64K
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHRQ  $0x08, R10
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x32, R9
+        SHLQ  $0x10, R10
+        IMULQ R8, R10
+        SHRQ  $0x32, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  24(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        LEAL  1(CX), R9
+        MOVL  R9, 24(SP)(R10*4)
+        MOVQ  SI, R9
+        SHRQ  $0x10, R9
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x32, R9
+        MOVL  CX, R8
+        SUBL  16(SP), R8
+        MOVL  1(DX)(R8*1), R10
+        MOVQ  SI, R8
+        SHRQ  $0x08, R8
+        CMPL  R8, R10
+        JNE   no_repeat_found_encodeSnappyBlockAsm64K
+        LEAL  1(CX), SI
+        MOVL  12(SP), BX
+        MOVL  SI, DI
+        SUBL  16(SP), DI
+        JZ    repeat_extend_back_end_encodeSnappyBlockAsm64K
+
+repeat_extend_back_loop_encodeSnappyBlockAsm64K:
+        CMPL SI, BX
+        JBE  repeat_extend_back_end_encodeSnappyBlockAsm64K
+        MOVB -1(DX)(DI*1), R8
+        MOVB -1(DX)(SI*1), R9
+        CMPB R8, R9
+        JNE  repeat_extend_back_end_encodeSnappyBlockAsm64K
+        LEAL -1(SI), SI
+        DECL DI
+        JNZ  repeat_extend_back_loop_encodeSnappyBlockAsm64K
+
+repeat_extend_back_end_encodeSnappyBlockAsm64K:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_repeat_emit_encodeSnappyBlockAsm64K
+        MOVL SI, DI
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R8
+        SUBL BX, DI
+        LEAL -1(DI), BX
+        CMPL BX, $0x3c
+        JB   one_byte_repeat_emit_encodeSnappyBlockAsm64K
+        CMPL BX, $0x00000100
+        JB   two_bytes_repeat_emit_encodeSnappyBlockAsm64K
+        JB   three_bytes_repeat_emit_encodeSnappyBlockAsm64K
+
+three_bytes_repeat_emit_encodeSnappyBlockAsm64K:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_repeat_emit_encodeSnappyBlockAsm64K
+
+two_bytes_repeat_emit_encodeSnappyBlockAsm64K:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_repeat_emit_encodeSnappyBlockAsm64K
+        JMP  memmove_long_repeat_emit_encodeSnappyBlockAsm64K
+
+one_byte_repeat_emit_encodeSnappyBlockAsm64K:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_repeat_emit_encodeSnappyBlockAsm64K:
+        LEAQ (AX)(DI*1), BX
+
+        // genMemMoveShort
+        CMPQ DI, $0x08
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm64K_memmove_move_8
+        CMPQ DI, $0x10
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm64K_memmove_move_8through16
+        CMPQ DI, $0x20
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm64K_memmove_move_17through32
+        JMP  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm64K_memmove_move_33through64
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm64K_memmove_move_8:
+        MOVQ (R8), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_repeat_emit_encodeSnappyBlockAsm64K
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm64K_memmove_move_8through16:
+        MOVQ (R8), R9
+        MOVQ -8(R8)(DI*1), R8
+        MOVQ R9, (AX)
+        MOVQ R8, -8(AX)(DI*1)
+        JMP  memmove_end_copy_repeat_emit_encodeSnappyBlockAsm64K
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm64K_memmove_move_17through32:
+        MOVOU (R8), X0
+        MOVOU -16(R8)(DI*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(DI*1)
+        JMP   memmove_end_copy_repeat_emit_encodeSnappyBlockAsm64K
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm64K_memmove_move_33through64:
+        MOVOU (R8), X0
+        MOVOU 16(R8), X1
+        MOVOU -32(R8)(DI*1), X2
+        MOVOU -16(R8)(DI*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(DI*1)
+        MOVOU X3, -16(AX)(DI*1)
+
+memmove_end_copy_repeat_emit_encodeSnappyBlockAsm64K:
+        MOVQ BX, AX
+        JMP  emit_literal_done_repeat_emit_encodeSnappyBlockAsm64K
+
+memmove_long_repeat_emit_encodeSnappyBlockAsm64K:
+        LEAQ (AX)(DI*1), BX
+
+        // genMemMoveLong
+        MOVOU (R8), X0
+        MOVOU 16(R8), X1
+        MOVOU -32(R8)(DI*1), X2
+        MOVOU -16(R8)(DI*1), X3
+        MOVQ  DI, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm64Klarge_forward_sse_loop_32
+        LEAQ  -32(R8)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm64Klarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm64Klarge_big_loop_back
+
+emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm64Klarge_forward_sse_loop_32:
+        MOVOU -32(R8)(R11*1), X4
+        MOVOU -16(R8)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  DI, R11
+        JAE   emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm64Klarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(DI*1)
+        MOVOU X3, -16(AX)(DI*1)
+        MOVQ  BX, AX
+
+emit_literal_done_repeat_emit_encodeSnappyBlockAsm64K:
+        ADDL $0x05, CX
+        MOVL CX, BX
+        SUBL 16(SP), BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R10, R10
+
+matchlen_loopback_16_repeat_extend_encodeSnappyBlockAsm64K:
+        CMPL DI, $0x10
+        JB   matchlen_match8_repeat_extend_encodeSnappyBlockAsm64K
+        MOVQ (R8)(R10*1), R9
+        MOVQ 8(R8)(R10*1), R11
+        XORQ (BX)(R10*1), R9
+        JNZ  matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm64K
+        XORQ 8(BX)(R10*1), R11
+        JNZ  matchlen_bsf_16repeat_extend_encodeSnappyBlockAsm64K
+        LEAL -16(DI), DI
+        LEAL 16(R10), R10
+        JMP  matchlen_loopback_16_repeat_extend_encodeSnappyBlockAsm64K
+
+matchlen_bsf_16repeat_extend_encodeSnappyBlockAsm64K:
+#ifdef GOAMD64_v3
+        TZCNTQ R11, R11
+
+#else
+        BSFQ R11, R11
+
+#endif
+        SARQ $0x03, R11
+        LEAL 8(R10)(R11*1), R10
+        JMP  repeat_extend_forward_end_encodeSnappyBlockAsm64K
+
+matchlen_match8_repeat_extend_encodeSnappyBlockAsm64K:
+        CMPL DI, $0x08
+        JB   matchlen_match4_repeat_extend_encodeSnappyBlockAsm64K
+        MOVQ (R8)(R10*1), R9
+        XORQ (BX)(R10*1), R9
+        JNZ  matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm64K
+        LEAL -8(DI), DI
+        LEAL 8(R10), R10
+        JMP  matchlen_match4_repeat_extend_encodeSnappyBlockAsm64K
+
+matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm64K:
+#ifdef GOAMD64_v3
+        TZCNTQ R9, R9
+
+#else
+        BSFQ R9, R9
+
+#endif
+        SARQ $0x03, R9
+        LEAL (R10)(R9*1), R10
+        JMP  repeat_extend_forward_end_encodeSnappyBlockAsm64K
+
+matchlen_match4_repeat_extend_encodeSnappyBlockAsm64K:
+        CMPL DI, $0x04
+        JB   matchlen_match2_repeat_extend_encodeSnappyBlockAsm64K
+        MOVL (R8)(R10*1), R9
+        CMPL (BX)(R10*1), R9
+        JNE  matchlen_match2_repeat_extend_encodeSnappyBlockAsm64K
+        LEAL -4(DI), DI
+        LEAL 4(R10), R10
+
+matchlen_match2_repeat_extend_encodeSnappyBlockAsm64K:
+        CMPL DI, $0x01
+        JE   matchlen_match1_repeat_extend_encodeSnappyBlockAsm64K
+        JB   repeat_extend_forward_end_encodeSnappyBlockAsm64K
+        MOVW (R8)(R10*1), R9
+        CMPW (BX)(R10*1), R9
+        JNE  matchlen_match1_repeat_extend_encodeSnappyBlockAsm64K
+        LEAL 2(R10), R10
+        SUBL $0x02, DI
+        JZ   repeat_extend_forward_end_encodeSnappyBlockAsm64K
+
+matchlen_match1_repeat_extend_encodeSnappyBlockAsm64K:
+        MOVB (R8)(R10*1), R9
+        CMPB (BX)(R10*1), R9
+        JNE  repeat_extend_forward_end_encodeSnappyBlockAsm64K
+        LEAL 1(R10), R10
+
+repeat_extend_forward_end_encodeSnappyBlockAsm64K:
+        ADDL R10, CX
+        MOVL CX, BX
+        SUBL SI, BX
+        MOVL 16(SP), SI
+
+        // emitCopy
+two_byte_offset_repeat_as_copy_encodeSnappyBlockAsm64K:
+        CMPL BX, $0x40
+        JBE  two_byte_offset_short_repeat_as_copy_encodeSnappyBlockAsm64K
+        MOVB $0xee, (AX)
+        MOVW SI, 1(AX)
+        LEAL -60(BX), BX
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_repeat_as_copy_encodeSnappyBlockAsm64K
+
+two_byte_offset_short_repeat_as_copy_encodeSnappyBlockAsm64K:
+        MOVL BX, DI
+        SHLL $0x02, DI
+        CMPL BX, $0x0c
+        JAE  emit_copy_three_repeat_as_copy_encodeSnappyBlockAsm64K
+        CMPL SI, $0x00000800
+        JAE  emit_copy_three_repeat_as_copy_encodeSnappyBlockAsm64K
+        LEAL -15(DI), DI
+        MOVB SI, 1(AX)
+        SHRL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeSnappyBlockAsm64K
+
+emit_copy_three_repeat_as_copy_encodeSnappyBlockAsm64K:
+        LEAL -2(DI), DI
+        MOVB DI, (AX)
+        MOVW SI, 1(AX)
+        ADDQ $0x03, AX
+
+repeat_end_emit_encodeSnappyBlockAsm64K:
+        MOVL CX, 12(SP)
+        JMP  search_loop_encodeSnappyBlockAsm64K
+
+no_repeat_found_encodeSnappyBlockAsm64K:
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate_match_encodeSnappyBlockAsm64K
+        SHRQ $0x08, SI
+        MOVL 24(SP)(R9*4), BX
+        LEAL 2(CX), R8
+        CMPL (DX)(DI*1), SI
+        JEQ  candidate2_match_encodeSnappyBlockAsm64K
+        MOVL R8, 24(SP)(R9*4)
+        SHRQ $0x08, SI
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate3_match_encodeSnappyBlockAsm64K
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeSnappyBlockAsm64K
+
+candidate3_match_encodeSnappyBlockAsm64K:
+        ADDL $0x02, CX
+        JMP  candidate_match_encodeSnappyBlockAsm64K
+
+candidate2_match_encodeSnappyBlockAsm64K:
+        MOVL R8, 24(SP)(R9*4)
+        INCL CX
+        MOVL DI, BX
+
+candidate_match_encodeSnappyBlockAsm64K:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeSnappyBlockAsm64K
+
+match_extend_back_loop_encodeSnappyBlockAsm64K:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeSnappyBlockAsm64K
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeSnappyBlockAsm64K
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeSnappyBlockAsm64K
+        JMP  match_extend_back_loop_encodeSnappyBlockAsm64K
+
+match_extend_back_end_encodeSnappyBlockAsm64K:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeSnappyBlockAsm64K
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeSnappyBlockAsm64K:
+        MOVL CX, SI
+        MOVL 12(SP), DI
+        CMPL DI, SI
+        JEQ  emit_literal_done_match_emit_encodeSnappyBlockAsm64K
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(DI*1), SI
+        SUBL DI, R8
+        LEAL -1(R8), DI
+        CMPL DI, $0x3c
+        JB   one_byte_match_emit_encodeSnappyBlockAsm64K
+        CMPL DI, $0x00000100
+        JB   two_bytes_match_emit_encodeSnappyBlockAsm64K
+        JB   three_bytes_match_emit_encodeSnappyBlockAsm64K
+
+three_bytes_match_emit_encodeSnappyBlockAsm64K:
+        MOVB $0xf4, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeSnappyBlockAsm64K
+
+two_bytes_match_emit_encodeSnappyBlockAsm64K:
+        MOVB $0xf0, (AX)
+        MOVB DI, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DI, $0x40
+        JB   memmove_match_emit_encodeSnappyBlockAsm64K
+        JMP  memmove_long_match_emit_encodeSnappyBlockAsm64K
+
+one_byte_match_emit_encodeSnappyBlockAsm64K:
+        SHLB $0x02, DI
+        MOVB DI, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeSnappyBlockAsm64K:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm64K_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm64K_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm64K_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeSnappyBlockAsm64K_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm64K_memmove_move_8:
+        MOVQ (SI), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBlockAsm64K
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm64K_memmove_move_8through16:
+        MOVQ (SI), R9
+        MOVQ -8(SI)(R8*1), SI
+        MOVQ R9, (AX)
+        MOVQ SI, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBlockAsm64K
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm64K_memmove_move_17through32:
+        MOVOU (SI), X0
+        MOVOU -16(SI)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeSnappyBlockAsm64K
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm64K_memmove_move_33through64:
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeSnappyBlockAsm64K:
+        MOVQ DI, AX
+        JMP  emit_literal_done_match_emit_encodeSnappyBlockAsm64K
+
+memmove_long_match_emit_encodeSnappyBlockAsm64K:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveLong
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVQ  R8, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm64Klarge_forward_sse_loop_32
+        LEAQ  -32(SI)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm64Klarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm64Klarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm64Klarge_forward_sse_loop_32:
+        MOVOU -32(SI)(R11*1), X4
+        MOVOU -16(SI)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  R8, R11
+        JAE   emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm64Klarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  DI, AX
+
+emit_literal_done_match_emit_encodeSnappyBlockAsm64K:
+match_nolit_loop_encodeSnappyBlockAsm64K:
+        MOVL CX, SI
+        SUBL BX, SI
+        MOVL SI, 16(SP)
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), SI
+        SUBL CX, SI
+        LEAQ (DX)(CX*1), DI
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R9, R9
+
+matchlen_loopback_16_match_nolit_encodeSnappyBlockAsm64K:
+        CMPL SI, $0x10
+        JB   matchlen_match8_match_nolit_encodeSnappyBlockAsm64K
+        MOVQ (DI)(R9*1), R8
+        MOVQ 8(DI)(R9*1), R10
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm64K
+        XORQ 8(BX)(R9*1), R10
+        JNZ  matchlen_bsf_16match_nolit_encodeSnappyBlockAsm64K
+        LEAL -16(SI), SI
+        LEAL 16(R9), R9
+        JMP  matchlen_loopback_16_match_nolit_encodeSnappyBlockAsm64K
+
+matchlen_bsf_16match_nolit_encodeSnappyBlockAsm64K:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL 8(R9)(R10*1), R9
+        JMP  match_nolit_end_encodeSnappyBlockAsm64K
+
+matchlen_match8_match_nolit_encodeSnappyBlockAsm64K:
+        CMPL SI, $0x08
+        JB   matchlen_match4_match_nolit_encodeSnappyBlockAsm64K
+        MOVQ (DI)(R9*1), R8
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm64K
+        LEAL -8(SI), SI
+        LEAL 8(R9), R9
+        JMP  matchlen_match4_match_nolit_encodeSnappyBlockAsm64K
+
+matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm64K:
+#ifdef GOAMD64_v3
+        TZCNTQ R8, R8
+
+#else
+        BSFQ R8, R8
+
+#endif
+        SARQ $0x03, R8
+        LEAL (R9)(R8*1), R9
+        JMP  match_nolit_end_encodeSnappyBlockAsm64K
+
+matchlen_match4_match_nolit_encodeSnappyBlockAsm64K:
+        CMPL SI, $0x04
+        JB   matchlen_match2_match_nolit_encodeSnappyBlockAsm64K
+        MOVL (DI)(R9*1), R8
+        CMPL (BX)(R9*1), R8
+        JNE  matchlen_match2_match_nolit_encodeSnappyBlockAsm64K
+        LEAL -4(SI), SI
+        LEAL 4(R9), R9
+
+matchlen_match2_match_nolit_encodeSnappyBlockAsm64K:
+        CMPL SI, $0x01
+        JE   matchlen_match1_match_nolit_encodeSnappyBlockAsm64K
+        JB   match_nolit_end_encodeSnappyBlockAsm64K
+        MOVW (DI)(R9*1), R8
+        CMPW (BX)(R9*1), R8
+        JNE  matchlen_match1_match_nolit_encodeSnappyBlockAsm64K
+        LEAL 2(R9), R9
+        SUBL $0x02, SI
+        JZ   match_nolit_end_encodeSnappyBlockAsm64K
+
+matchlen_match1_match_nolit_encodeSnappyBlockAsm64K:
+        MOVB (DI)(R9*1), R8
+        CMPB (BX)(R9*1), R8
+        JNE  match_nolit_end_encodeSnappyBlockAsm64K
+        LEAL 1(R9), R9
+
+match_nolit_end_encodeSnappyBlockAsm64K:
+        ADDL R9, CX
+        MOVL 16(SP), BX
+        ADDL $0x04, R9
+        MOVL CX, 12(SP)
+
+        // emitCopy
+two_byte_offset_match_nolit_encodeSnappyBlockAsm64K:
+        CMPL R9, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeSnappyBlockAsm64K
+        MOVB $0xee, (AX)
+        MOVW BX, 1(AX)
+        LEAL -60(R9), R9
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_match_nolit_encodeSnappyBlockAsm64K
+
+two_byte_offset_short_match_nolit_encodeSnappyBlockAsm64K:
+        MOVL R9, SI
+        SHLL $0x02, SI
+        CMPL R9, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeSnappyBlockAsm64K
+        CMPL BX, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeSnappyBlockAsm64K
+        LEAL -15(SI), SI
+        MOVB BL, 1(AX)
+        SHRL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeSnappyBlockAsm64K
+
+emit_copy_three_match_nolit_encodeSnappyBlockAsm64K:
+        LEAL -2(SI), SI
+        MOVB SI, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeSnappyBlockAsm64K:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeSnappyBlockAsm64K
+        MOVQ -2(DX)(CX*1), SI
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeSnappyBlockAsm64K
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeSnappyBlockAsm64K:
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  SI, DI
+        SHRQ  $0x10, SI
+        MOVQ  SI, BX
+        SHLQ  $0x10, DI
+        IMULQ R8, DI
+        SHRQ  $0x32, DI
+        SHLQ  $0x10, BX
+        IMULQ R8, BX
+        SHRQ  $0x32, BX
+        LEAL  -2(CX), R8
+        LEAQ  24(SP)(BX*4), R9
+        MOVL  (R9), BX
+        MOVL  R8, 24(SP)(DI*4)
+        MOVL  CX, (R9)
+        CMPL  (DX)(BX*1), SI
+        JEQ   match_nolit_loop_encodeSnappyBlockAsm64K
+        INCL  CX
+        JMP   search_loop_encodeSnappyBlockAsm64K
+
+emit_remainder_encodeSnappyBlockAsm64K:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeSnappyBlockAsm64K
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeSnappyBlockAsm64K:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeSnappyBlockAsm64K
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeSnappyBlockAsm64K
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeSnappyBlockAsm64K
+        JB   three_bytes_emit_remainder_encodeSnappyBlockAsm64K
+
+three_bytes_emit_remainder_encodeSnappyBlockAsm64K:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeSnappyBlockAsm64K
+
+two_bytes_emit_remainder_encodeSnappyBlockAsm64K:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeSnappyBlockAsm64K
+        JMP  memmove_long_emit_remainder_encodeSnappyBlockAsm64K
+
+one_byte_emit_remainder_encodeSnappyBlockAsm64K:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeSnappyBlockAsm64K:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm64K_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm64K_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm64K_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm64K_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm64K_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm64K_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm64K_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm64K
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm64K_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm64K
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm64K_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm64K
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm64K_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm64K
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm64K_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeSnappyBlockAsm64K
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm64K_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeSnappyBlockAsm64K:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeSnappyBlockAsm64K
+
+memmove_long_emit_remainder_encodeSnappyBlockAsm64K:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm64Klarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm64Klarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm64Klarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm64Klarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm64Klarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeSnappyBlockAsm64K:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeSnappyBlockAsm12B(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeSnappyBlockAsm12B(SB), $16408-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000080, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeSnappyBlockAsm12B:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeSnappyBlockAsm12B
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  CX, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeSnappyBlockAsm12B:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x05, BX
+        LEAL  4(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeSnappyBlockAsm12B
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x000000cf1bbcdcbb, R8
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHRQ  $0x08, R10
+        SHLQ  $0x18, R9
+        IMULQ R8, R9
+        SHRQ  $0x34, R9
+        SHLQ  $0x18, R10
+        IMULQ R8, R10
+        SHRQ  $0x34, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  24(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        LEAL  1(CX), R9
+        MOVL  R9, 24(SP)(R10*4)
+        MOVQ  SI, R9
+        SHRQ  $0x10, R9
+        SHLQ  $0x18, R9
+        IMULQ R8, R9
+        SHRQ  $0x34, R9
+        MOVL  CX, R8
+        SUBL  16(SP), R8
+        MOVL  1(DX)(R8*1), R10
+        MOVQ  SI, R8
+        SHRQ  $0x08, R8
+        CMPL  R8, R10
+        JNE   no_repeat_found_encodeSnappyBlockAsm12B
+        LEAL  1(CX), SI
+        MOVL  12(SP), BX
+        MOVL  SI, DI
+        SUBL  16(SP), DI
+        JZ    repeat_extend_back_end_encodeSnappyBlockAsm12B
+
+repeat_extend_back_loop_encodeSnappyBlockAsm12B:
+        CMPL SI, BX
+        JBE  repeat_extend_back_end_encodeSnappyBlockAsm12B
+        MOVB -1(DX)(DI*1), R8
+        MOVB -1(DX)(SI*1), R9
+        CMPB R8, R9
+        JNE  repeat_extend_back_end_encodeSnappyBlockAsm12B
+        LEAL -1(SI), SI
+        DECL DI
+        JNZ  repeat_extend_back_loop_encodeSnappyBlockAsm12B
+
+repeat_extend_back_end_encodeSnappyBlockAsm12B:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_repeat_emit_encodeSnappyBlockAsm12B
+        MOVL SI, DI
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R8
+        SUBL BX, DI
+        LEAL -1(DI), BX
+        CMPL BX, $0x3c
+        JB   one_byte_repeat_emit_encodeSnappyBlockAsm12B
+        CMPL BX, $0x00000100
+        JB   two_bytes_repeat_emit_encodeSnappyBlockAsm12B
+        JB   three_bytes_repeat_emit_encodeSnappyBlockAsm12B
+
+three_bytes_repeat_emit_encodeSnappyBlockAsm12B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_repeat_emit_encodeSnappyBlockAsm12B
+
+two_bytes_repeat_emit_encodeSnappyBlockAsm12B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_repeat_emit_encodeSnappyBlockAsm12B
+        JMP  memmove_long_repeat_emit_encodeSnappyBlockAsm12B
+
+one_byte_repeat_emit_encodeSnappyBlockAsm12B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_repeat_emit_encodeSnappyBlockAsm12B:
+        LEAQ (AX)(DI*1), BX
+
+        // genMemMoveShort
+        CMPQ DI, $0x08
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm12B_memmove_move_8
+        CMPQ DI, $0x10
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm12B_memmove_move_8through16
+        CMPQ DI, $0x20
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm12B_memmove_move_17through32
+        JMP  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm12B_memmove_move_33through64
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm12B_memmove_move_8:
+        MOVQ (R8), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_repeat_emit_encodeSnappyBlockAsm12B
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm12B_memmove_move_8through16:
+        MOVQ (R8), R9
+        MOVQ -8(R8)(DI*1), R8
+        MOVQ R9, (AX)
+        MOVQ R8, -8(AX)(DI*1)
+        JMP  memmove_end_copy_repeat_emit_encodeSnappyBlockAsm12B
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm12B_memmove_move_17through32:
+        MOVOU (R8), X0
+        MOVOU -16(R8)(DI*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(DI*1)
+        JMP   memmove_end_copy_repeat_emit_encodeSnappyBlockAsm12B
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm12B_memmove_move_33through64:
+        MOVOU (R8), X0
+        MOVOU 16(R8), X1
+        MOVOU -32(R8)(DI*1), X2
+        MOVOU -16(R8)(DI*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(DI*1)
+        MOVOU X3, -16(AX)(DI*1)
+
+memmove_end_copy_repeat_emit_encodeSnappyBlockAsm12B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_repeat_emit_encodeSnappyBlockAsm12B
+
+memmove_long_repeat_emit_encodeSnappyBlockAsm12B:
+        LEAQ (AX)(DI*1), BX
+
+        // genMemMoveLong
+        MOVOU (R8), X0
+        MOVOU 16(R8), X1
+        MOVOU -32(R8)(DI*1), X2
+        MOVOU -16(R8)(DI*1), X3
+        MOVQ  DI, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm12Blarge_forward_sse_loop_32
+        LEAQ  -32(R8)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm12Blarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm12Blarge_big_loop_back
+
+emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm12Blarge_forward_sse_loop_32:
+        MOVOU -32(R8)(R11*1), X4
+        MOVOU -16(R8)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  DI, R11
+        JAE   emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm12Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(DI*1)
+        MOVOU X3, -16(AX)(DI*1)
+        MOVQ  BX, AX
+
+emit_literal_done_repeat_emit_encodeSnappyBlockAsm12B:
+        ADDL $0x05, CX
+        MOVL CX, BX
+        SUBL 16(SP), BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R10, R10
+
+matchlen_loopback_16_repeat_extend_encodeSnappyBlockAsm12B:
+        CMPL DI, $0x10
+        JB   matchlen_match8_repeat_extend_encodeSnappyBlockAsm12B
+        MOVQ (R8)(R10*1), R9
+        MOVQ 8(R8)(R10*1), R11
+        XORQ (BX)(R10*1), R9
+        JNZ  matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm12B
+        XORQ 8(BX)(R10*1), R11
+        JNZ  matchlen_bsf_16repeat_extend_encodeSnappyBlockAsm12B
+        LEAL -16(DI), DI
+        LEAL 16(R10), R10
+        JMP  matchlen_loopback_16_repeat_extend_encodeSnappyBlockAsm12B
+
+matchlen_bsf_16repeat_extend_encodeSnappyBlockAsm12B:
+#ifdef GOAMD64_v3
+        TZCNTQ R11, R11
+
+#else
+        BSFQ R11, R11
+
+#endif
+        SARQ $0x03, R11
+        LEAL 8(R10)(R11*1), R10
+        JMP  repeat_extend_forward_end_encodeSnappyBlockAsm12B
+
+matchlen_match8_repeat_extend_encodeSnappyBlockAsm12B:
+        CMPL DI, $0x08
+        JB   matchlen_match4_repeat_extend_encodeSnappyBlockAsm12B
+        MOVQ (R8)(R10*1), R9
+        XORQ (BX)(R10*1), R9
+        JNZ  matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm12B
+        LEAL -8(DI), DI
+        LEAL 8(R10), R10
+        JMP  matchlen_match4_repeat_extend_encodeSnappyBlockAsm12B
+
+matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm12B:
+#ifdef GOAMD64_v3
+        TZCNTQ R9, R9
+
+#else
+        BSFQ R9, R9
+
+#endif
+        SARQ $0x03, R9
+        LEAL (R10)(R9*1), R10
+        JMP  repeat_extend_forward_end_encodeSnappyBlockAsm12B
+
+matchlen_match4_repeat_extend_encodeSnappyBlockAsm12B:
+        CMPL DI, $0x04
+        JB   matchlen_match2_repeat_extend_encodeSnappyBlockAsm12B
+        MOVL (R8)(R10*1), R9
+        CMPL (BX)(R10*1), R9
+        JNE  matchlen_match2_repeat_extend_encodeSnappyBlockAsm12B
+        LEAL -4(DI), DI
+        LEAL 4(R10), R10
+
+matchlen_match2_repeat_extend_encodeSnappyBlockAsm12B:
+        CMPL DI, $0x01
+        JE   matchlen_match1_repeat_extend_encodeSnappyBlockAsm12B
+        JB   repeat_extend_forward_end_encodeSnappyBlockAsm12B
+        MOVW (R8)(R10*1), R9
+        CMPW (BX)(R10*1), R9
+        JNE  matchlen_match1_repeat_extend_encodeSnappyBlockAsm12B
+        LEAL 2(R10), R10
+        SUBL $0x02, DI
+        JZ   repeat_extend_forward_end_encodeSnappyBlockAsm12B
+
+matchlen_match1_repeat_extend_encodeSnappyBlockAsm12B:
+        MOVB (R8)(R10*1), R9
+        CMPB (BX)(R10*1), R9
+        JNE  repeat_extend_forward_end_encodeSnappyBlockAsm12B
+        LEAL 1(R10), R10
+
+repeat_extend_forward_end_encodeSnappyBlockAsm12B:
+        ADDL R10, CX
+        MOVL CX, BX
+        SUBL SI, BX
+        MOVL 16(SP), SI
+
+        // emitCopy
+two_byte_offset_repeat_as_copy_encodeSnappyBlockAsm12B:
+        CMPL BX, $0x40
+        JBE  two_byte_offset_short_repeat_as_copy_encodeSnappyBlockAsm12B
+        MOVB $0xee, (AX)
+        MOVW SI, 1(AX)
+        LEAL -60(BX), BX
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_repeat_as_copy_encodeSnappyBlockAsm12B
+
+two_byte_offset_short_repeat_as_copy_encodeSnappyBlockAsm12B:
+        MOVL BX, DI
+        SHLL $0x02, DI
+        CMPL BX, $0x0c
+        JAE  emit_copy_three_repeat_as_copy_encodeSnappyBlockAsm12B
+        CMPL SI, $0x00000800
+        JAE  emit_copy_three_repeat_as_copy_encodeSnappyBlockAsm12B
+        LEAL -15(DI), DI
+        MOVB SI, 1(AX)
+        SHRL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeSnappyBlockAsm12B
+
+emit_copy_three_repeat_as_copy_encodeSnappyBlockAsm12B:
+        LEAL -2(DI), DI
+        MOVB DI, (AX)
+        MOVW SI, 1(AX)
+        ADDQ $0x03, AX
+
+repeat_end_emit_encodeSnappyBlockAsm12B:
+        MOVL CX, 12(SP)
+        JMP  search_loop_encodeSnappyBlockAsm12B
+
+no_repeat_found_encodeSnappyBlockAsm12B:
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate_match_encodeSnappyBlockAsm12B
+        SHRQ $0x08, SI
+        MOVL 24(SP)(R9*4), BX
+        LEAL 2(CX), R8
+        CMPL (DX)(DI*1), SI
+        JEQ  candidate2_match_encodeSnappyBlockAsm12B
+        MOVL R8, 24(SP)(R9*4)
+        SHRQ $0x08, SI
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate3_match_encodeSnappyBlockAsm12B
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeSnappyBlockAsm12B
+
+candidate3_match_encodeSnappyBlockAsm12B:
+        ADDL $0x02, CX
+        JMP  candidate_match_encodeSnappyBlockAsm12B
+
+candidate2_match_encodeSnappyBlockAsm12B:
+        MOVL R8, 24(SP)(R9*4)
+        INCL CX
+        MOVL DI, BX
+
+candidate_match_encodeSnappyBlockAsm12B:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeSnappyBlockAsm12B
+
+match_extend_back_loop_encodeSnappyBlockAsm12B:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeSnappyBlockAsm12B
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeSnappyBlockAsm12B
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeSnappyBlockAsm12B
+        JMP  match_extend_back_loop_encodeSnappyBlockAsm12B
+
+match_extend_back_end_encodeSnappyBlockAsm12B:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeSnappyBlockAsm12B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeSnappyBlockAsm12B:
+        MOVL CX, SI
+        MOVL 12(SP), DI
+        CMPL DI, SI
+        JEQ  emit_literal_done_match_emit_encodeSnappyBlockAsm12B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(DI*1), SI
+        SUBL DI, R8
+        LEAL -1(R8), DI
+        CMPL DI, $0x3c
+        JB   one_byte_match_emit_encodeSnappyBlockAsm12B
+        CMPL DI, $0x00000100
+        JB   two_bytes_match_emit_encodeSnappyBlockAsm12B
+        JB   three_bytes_match_emit_encodeSnappyBlockAsm12B
+
+three_bytes_match_emit_encodeSnappyBlockAsm12B:
+        MOVB $0xf4, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeSnappyBlockAsm12B
+
+two_bytes_match_emit_encodeSnappyBlockAsm12B:
+        MOVB $0xf0, (AX)
+        MOVB DI, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DI, $0x40
+        JB   memmove_match_emit_encodeSnappyBlockAsm12B
+        JMP  memmove_long_match_emit_encodeSnappyBlockAsm12B
+
+one_byte_match_emit_encodeSnappyBlockAsm12B:
+        SHLB $0x02, DI
+        MOVB DI, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeSnappyBlockAsm12B:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm12B_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm12B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm12B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeSnappyBlockAsm12B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm12B_memmove_move_8:
+        MOVQ (SI), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBlockAsm12B
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm12B_memmove_move_8through16:
+        MOVQ (SI), R9
+        MOVQ -8(SI)(R8*1), SI
+        MOVQ R9, (AX)
+        MOVQ SI, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBlockAsm12B
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm12B_memmove_move_17through32:
+        MOVOU (SI), X0
+        MOVOU -16(SI)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeSnappyBlockAsm12B
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm12B_memmove_move_33through64:
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeSnappyBlockAsm12B:
+        MOVQ DI, AX
+        JMP  emit_literal_done_match_emit_encodeSnappyBlockAsm12B
+
+memmove_long_match_emit_encodeSnappyBlockAsm12B:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveLong
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVQ  R8, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm12Blarge_forward_sse_loop_32
+        LEAQ  -32(SI)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm12Blarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm12Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm12Blarge_forward_sse_loop_32:
+        MOVOU -32(SI)(R11*1), X4
+        MOVOU -16(SI)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  R8, R11
+        JAE   emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm12Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  DI, AX
+
+emit_literal_done_match_emit_encodeSnappyBlockAsm12B:
+match_nolit_loop_encodeSnappyBlockAsm12B:
+        MOVL CX, SI
+        SUBL BX, SI
+        MOVL SI, 16(SP)
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), SI
+        SUBL CX, SI
+        LEAQ (DX)(CX*1), DI
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R9, R9
+
+matchlen_loopback_16_match_nolit_encodeSnappyBlockAsm12B:
+        CMPL SI, $0x10
+        JB   matchlen_match8_match_nolit_encodeSnappyBlockAsm12B
+        MOVQ (DI)(R9*1), R8
+        MOVQ 8(DI)(R9*1), R10
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm12B
+        XORQ 8(BX)(R9*1), R10
+        JNZ  matchlen_bsf_16match_nolit_encodeSnappyBlockAsm12B
+        LEAL -16(SI), SI
+        LEAL 16(R9), R9
+        JMP  matchlen_loopback_16_match_nolit_encodeSnappyBlockAsm12B
+
+matchlen_bsf_16match_nolit_encodeSnappyBlockAsm12B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL 8(R9)(R10*1), R9
+        JMP  match_nolit_end_encodeSnappyBlockAsm12B
+
+matchlen_match8_match_nolit_encodeSnappyBlockAsm12B:
+        CMPL SI, $0x08
+        JB   matchlen_match4_match_nolit_encodeSnappyBlockAsm12B
+        MOVQ (DI)(R9*1), R8
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm12B
+        LEAL -8(SI), SI
+        LEAL 8(R9), R9
+        JMP  matchlen_match4_match_nolit_encodeSnappyBlockAsm12B
+
+matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm12B:
+#ifdef GOAMD64_v3
+        TZCNTQ R8, R8
+
+#else
+        BSFQ R8, R8
+
+#endif
+        SARQ $0x03, R8
+        LEAL (R9)(R8*1), R9
+        JMP  match_nolit_end_encodeSnappyBlockAsm12B
+
+matchlen_match4_match_nolit_encodeSnappyBlockAsm12B:
+        CMPL SI, $0x04
+        JB   matchlen_match2_match_nolit_encodeSnappyBlockAsm12B
+        MOVL (DI)(R9*1), R8
+        CMPL (BX)(R9*1), R8
+        JNE  matchlen_match2_match_nolit_encodeSnappyBlockAsm12B
+        LEAL -4(SI), SI
+        LEAL 4(R9), R9
+
+matchlen_match2_match_nolit_encodeSnappyBlockAsm12B:
+        CMPL SI, $0x01
+        JE   matchlen_match1_match_nolit_encodeSnappyBlockAsm12B
+        JB   match_nolit_end_encodeSnappyBlockAsm12B
+        MOVW (DI)(R9*1), R8
+        CMPW (BX)(R9*1), R8
+        JNE  matchlen_match1_match_nolit_encodeSnappyBlockAsm12B
+        LEAL 2(R9), R9
+        SUBL $0x02, SI
+        JZ   match_nolit_end_encodeSnappyBlockAsm12B
+
+matchlen_match1_match_nolit_encodeSnappyBlockAsm12B:
+        MOVB (DI)(R9*1), R8
+        CMPB (BX)(R9*1), R8
+        JNE  match_nolit_end_encodeSnappyBlockAsm12B
+        LEAL 1(R9), R9
+
+match_nolit_end_encodeSnappyBlockAsm12B:
+        ADDL R9, CX
+        MOVL 16(SP), BX
+        ADDL $0x04, R9
+        MOVL CX, 12(SP)
+
+        // emitCopy
+two_byte_offset_match_nolit_encodeSnappyBlockAsm12B:
+        CMPL R9, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeSnappyBlockAsm12B
+        MOVB $0xee, (AX)
+        MOVW BX, 1(AX)
+        LEAL -60(R9), R9
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_match_nolit_encodeSnappyBlockAsm12B
+
+two_byte_offset_short_match_nolit_encodeSnappyBlockAsm12B:
+        MOVL R9, SI
+        SHLL $0x02, SI
+        CMPL R9, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeSnappyBlockAsm12B
+        CMPL BX, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeSnappyBlockAsm12B
+        LEAL -15(SI), SI
+        MOVB BL, 1(AX)
+        SHRL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeSnappyBlockAsm12B
+
+emit_copy_three_match_nolit_encodeSnappyBlockAsm12B:
+        LEAL -2(SI), SI
+        MOVB SI, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeSnappyBlockAsm12B:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeSnappyBlockAsm12B
+        MOVQ -2(DX)(CX*1), SI
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeSnappyBlockAsm12B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeSnappyBlockAsm12B:
+        MOVQ  $0x000000cf1bbcdcbb, R8
+        MOVQ  SI, DI
+        SHRQ  $0x10, SI
+        MOVQ  SI, BX
+        SHLQ  $0x18, DI
+        IMULQ R8, DI
+        SHRQ  $0x34, DI
+        SHLQ  $0x18, BX
+        IMULQ R8, BX
+        SHRQ  $0x34, BX
+        LEAL  -2(CX), R8
+        LEAQ  24(SP)(BX*4), R9
+        MOVL  (R9), BX
+        MOVL  R8, 24(SP)(DI*4)
+        MOVL  CX, (R9)
+        CMPL  (DX)(BX*1), SI
+        JEQ   match_nolit_loop_encodeSnappyBlockAsm12B
+        INCL  CX
+        JMP   search_loop_encodeSnappyBlockAsm12B
+
+emit_remainder_encodeSnappyBlockAsm12B:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeSnappyBlockAsm12B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeSnappyBlockAsm12B:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeSnappyBlockAsm12B
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeSnappyBlockAsm12B
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeSnappyBlockAsm12B
+        JB   three_bytes_emit_remainder_encodeSnappyBlockAsm12B
+
+three_bytes_emit_remainder_encodeSnappyBlockAsm12B:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeSnappyBlockAsm12B
+
+two_bytes_emit_remainder_encodeSnappyBlockAsm12B:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeSnappyBlockAsm12B
+        JMP  memmove_long_emit_remainder_encodeSnappyBlockAsm12B
+
+one_byte_emit_remainder_encodeSnappyBlockAsm12B:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeSnappyBlockAsm12B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm12B_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm12B_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm12B_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm12B_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm12B_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm12B_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm12B_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm12B_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm12B_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm12B_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm12B_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeSnappyBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm12B_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeSnappyBlockAsm12B:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeSnappyBlockAsm12B
+
+memmove_long_emit_remainder_encodeSnappyBlockAsm12B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm12Blarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm12Blarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm12Blarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm12Blarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm12Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeSnappyBlockAsm12B:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeSnappyBlockAsm10B(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeSnappyBlockAsm10B(SB), $4120-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000020, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeSnappyBlockAsm10B:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeSnappyBlockAsm10B
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  CX, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeSnappyBlockAsm10B:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x05, BX
+        LEAL  4(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeSnappyBlockAsm10B
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x9e3779b1, R8
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHRQ  $0x08, R10
+        SHLQ  $0x20, R9
+        IMULQ R8, R9
+        SHRQ  $0x36, R9
+        SHLQ  $0x20, R10
+        IMULQ R8, R10
+        SHRQ  $0x36, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  24(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        LEAL  1(CX), R9
+        MOVL  R9, 24(SP)(R10*4)
+        MOVQ  SI, R9
+        SHRQ  $0x10, R9
+        SHLQ  $0x20, R9
+        IMULQ R8, R9
+        SHRQ  $0x36, R9
+        MOVL  CX, R8
+        SUBL  16(SP), R8
+        MOVL  1(DX)(R8*1), R10
+        MOVQ  SI, R8
+        SHRQ  $0x08, R8
+        CMPL  R8, R10
+        JNE   no_repeat_found_encodeSnappyBlockAsm10B
+        LEAL  1(CX), SI
+        MOVL  12(SP), BX
+        MOVL  SI, DI
+        SUBL  16(SP), DI
+        JZ    repeat_extend_back_end_encodeSnappyBlockAsm10B
+
+repeat_extend_back_loop_encodeSnappyBlockAsm10B:
+        CMPL SI, BX
+        JBE  repeat_extend_back_end_encodeSnappyBlockAsm10B
+        MOVB -1(DX)(DI*1), R8
+        MOVB -1(DX)(SI*1), R9
+        CMPB R8, R9
+        JNE  repeat_extend_back_end_encodeSnappyBlockAsm10B
+        LEAL -1(SI), SI
+        DECL DI
+        JNZ  repeat_extend_back_loop_encodeSnappyBlockAsm10B
+
+repeat_extend_back_end_encodeSnappyBlockAsm10B:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_repeat_emit_encodeSnappyBlockAsm10B
+        MOVL SI, DI
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R8
+        SUBL BX, DI
+        LEAL -1(DI), BX
+        CMPL BX, $0x3c
+        JB   one_byte_repeat_emit_encodeSnappyBlockAsm10B
+        CMPL BX, $0x00000100
+        JB   two_bytes_repeat_emit_encodeSnappyBlockAsm10B
+        JB   three_bytes_repeat_emit_encodeSnappyBlockAsm10B
+
+three_bytes_repeat_emit_encodeSnappyBlockAsm10B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_repeat_emit_encodeSnappyBlockAsm10B
+
+two_bytes_repeat_emit_encodeSnappyBlockAsm10B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_repeat_emit_encodeSnappyBlockAsm10B
+        JMP  memmove_long_repeat_emit_encodeSnappyBlockAsm10B
+
+one_byte_repeat_emit_encodeSnappyBlockAsm10B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_repeat_emit_encodeSnappyBlockAsm10B:
+        LEAQ (AX)(DI*1), BX
+
+        // genMemMoveShort
+        CMPQ DI, $0x08
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm10B_memmove_move_8
+        CMPQ DI, $0x10
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm10B_memmove_move_8through16
+        CMPQ DI, $0x20
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm10B_memmove_move_17through32
+        JMP  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm10B_memmove_move_33through64
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm10B_memmove_move_8:
+        MOVQ (R8), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_repeat_emit_encodeSnappyBlockAsm10B
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm10B_memmove_move_8through16:
+        MOVQ (R8), R9
+        MOVQ -8(R8)(DI*1), R8
+        MOVQ R9, (AX)
+        MOVQ R8, -8(AX)(DI*1)
+        JMP  memmove_end_copy_repeat_emit_encodeSnappyBlockAsm10B
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm10B_memmove_move_17through32:
+        MOVOU (R8), X0
+        MOVOU -16(R8)(DI*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(DI*1)
+        JMP   memmove_end_copy_repeat_emit_encodeSnappyBlockAsm10B
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm10B_memmove_move_33through64:
+        MOVOU (R8), X0
+        MOVOU 16(R8), X1
+        MOVOU -32(R8)(DI*1), X2
+        MOVOU -16(R8)(DI*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(DI*1)
+        MOVOU X3, -16(AX)(DI*1)
+
+memmove_end_copy_repeat_emit_encodeSnappyBlockAsm10B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_repeat_emit_encodeSnappyBlockAsm10B
+
+memmove_long_repeat_emit_encodeSnappyBlockAsm10B:
+        LEAQ (AX)(DI*1), BX
+
+        // genMemMoveLong
+        MOVOU (R8), X0
+        MOVOU 16(R8), X1
+        MOVOU -32(R8)(DI*1), X2
+        MOVOU -16(R8)(DI*1), X3
+        MOVQ  DI, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm10Blarge_forward_sse_loop_32
+        LEAQ  -32(R8)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm10Blarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm10Blarge_big_loop_back
+
+emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm10Blarge_forward_sse_loop_32:
+        MOVOU -32(R8)(R11*1), X4
+        MOVOU -16(R8)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  DI, R11
+        JAE   emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm10Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(DI*1)
+        MOVOU X3, -16(AX)(DI*1)
+        MOVQ  BX, AX
+
+emit_literal_done_repeat_emit_encodeSnappyBlockAsm10B:
+        ADDL $0x05, CX
+        MOVL CX, BX
+        SUBL 16(SP), BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R10, R10
+
+matchlen_loopback_16_repeat_extend_encodeSnappyBlockAsm10B:
+        CMPL DI, $0x10
+        JB   matchlen_match8_repeat_extend_encodeSnappyBlockAsm10B
+        MOVQ (R8)(R10*1), R9
+        MOVQ 8(R8)(R10*1), R11
+        XORQ (BX)(R10*1), R9
+        JNZ  matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm10B
+        XORQ 8(BX)(R10*1), R11
+        JNZ  matchlen_bsf_16repeat_extend_encodeSnappyBlockAsm10B
+        LEAL -16(DI), DI
+        LEAL 16(R10), R10
+        JMP  matchlen_loopback_16_repeat_extend_encodeSnappyBlockAsm10B
+
+matchlen_bsf_16repeat_extend_encodeSnappyBlockAsm10B:
+#ifdef GOAMD64_v3
+        TZCNTQ R11, R11
+
+#else
+        BSFQ R11, R11
+
+#endif
+        SARQ $0x03, R11
+        LEAL 8(R10)(R11*1), R10
+        JMP  repeat_extend_forward_end_encodeSnappyBlockAsm10B
+
+matchlen_match8_repeat_extend_encodeSnappyBlockAsm10B:
+        CMPL DI, $0x08
+        JB   matchlen_match4_repeat_extend_encodeSnappyBlockAsm10B
+        MOVQ (R8)(R10*1), R9
+        XORQ (BX)(R10*1), R9
+        JNZ  matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm10B
+        LEAL -8(DI), DI
+        LEAL 8(R10), R10
+        JMP  matchlen_match4_repeat_extend_encodeSnappyBlockAsm10B
+
+matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm10B:
+#ifdef GOAMD64_v3
+        TZCNTQ R9, R9
+
+#else
+        BSFQ R9, R9
+
+#endif
+        SARQ $0x03, R9
+        LEAL (R10)(R9*1), R10
+        JMP  repeat_extend_forward_end_encodeSnappyBlockAsm10B
+
+matchlen_match4_repeat_extend_encodeSnappyBlockAsm10B:
+        CMPL DI, $0x04
+        JB   matchlen_match2_repeat_extend_encodeSnappyBlockAsm10B
+        MOVL (R8)(R10*1), R9
+        CMPL (BX)(R10*1), R9
+        JNE  matchlen_match2_repeat_extend_encodeSnappyBlockAsm10B
+        LEAL -4(DI), DI
+        LEAL 4(R10), R10
+
+matchlen_match2_repeat_extend_encodeSnappyBlockAsm10B:
+        CMPL DI, $0x01
+        JE   matchlen_match1_repeat_extend_encodeSnappyBlockAsm10B
+        JB   repeat_extend_forward_end_encodeSnappyBlockAsm10B
+        MOVW (R8)(R10*1), R9
+        CMPW (BX)(R10*1), R9
+        JNE  matchlen_match1_repeat_extend_encodeSnappyBlockAsm10B
+        LEAL 2(R10), R10
+        SUBL $0x02, DI
+        JZ   repeat_extend_forward_end_encodeSnappyBlockAsm10B
+
+matchlen_match1_repeat_extend_encodeSnappyBlockAsm10B:
+        MOVB (R8)(R10*1), R9
+        CMPB (BX)(R10*1), R9
+        JNE  repeat_extend_forward_end_encodeSnappyBlockAsm10B
+        LEAL 1(R10), R10
+
+repeat_extend_forward_end_encodeSnappyBlockAsm10B:
+        ADDL R10, CX
+        MOVL CX, BX
+        SUBL SI, BX
+        MOVL 16(SP), SI
+
+        // emitCopy
+two_byte_offset_repeat_as_copy_encodeSnappyBlockAsm10B:
+        CMPL BX, $0x40
+        JBE  two_byte_offset_short_repeat_as_copy_encodeSnappyBlockAsm10B
+        MOVB $0xee, (AX)
+        MOVW SI, 1(AX)
+        LEAL -60(BX), BX
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_repeat_as_copy_encodeSnappyBlockAsm10B
+
+two_byte_offset_short_repeat_as_copy_encodeSnappyBlockAsm10B:
+        MOVL BX, DI
+        SHLL $0x02, DI
+        CMPL BX, $0x0c
+        JAE  emit_copy_three_repeat_as_copy_encodeSnappyBlockAsm10B
+        CMPL SI, $0x00000800
+        JAE  emit_copy_three_repeat_as_copy_encodeSnappyBlockAsm10B
+        LEAL -15(DI), DI
+        MOVB SI, 1(AX)
+        SHRL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeSnappyBlockAsm10B
+
+emit_copy_three_repeat_as_copy_encodeSnappyBlockAsm10B:
+        LEAL -2(DI), DI
+        MOVB DI, (AX)
+        MOVW SI, 1(AX)
+        ADDQ $0x03, AX
+
+repeat_end_emit_encodeSnappyBlockAsm10B:
+        MOVL CX, 12(SP)
+        JMP  search_loop_encodeSnappyBlockAsm10B
+
+no_repeat_found_encodeSnappyBlockAsm10B:
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate_match_encodeSnappyBlockAsm10B
+        SHRQ $0x08, SI
+        MOVL 24(SP)(R9*4), BX
+        LEAL 2(CX), R8
+        CMPL (DX)(DI*1), SI
+        JEQ  candidate2_match_encodeSnappyBlockAsm10B
+        MOVL R8, 24(SP)(R9*4)
+        SHRQ $0x08, SI
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate3_match_encodeSnappyBlockAsm10B
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeSnappyBlockAsm10B
+
+candidate3_match_encodeSnappyBlockAsm10B:
+        ADDL $0x02, CX
+        JMP  candidate_match_encodeSnappyBlockAsm10B
+
+candidate2_match_encodeSnappyBlockAsm10B:
+        MOVL R8, 24(SP)(R9*4)
+        INCL CX
+        MOVL DI, BX
+
+candidate_match_encodeSnappyBlockAsm10B:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeSnappyBlockAsm10B
+
+match_extend_back_loop_encodeSnappyBlockAsm10B:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeSnappyBlockAsm10B
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeSnappyBlockAsm10B
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeSnappyBlockAsm10B
+        JMP  match_extend_back_loop_encodeSnappyBlockAsm10B
+
+match_extend_back_end_encodeSnappyBlockAsm10B:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeSnappyBlockAsm10B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeSnappyBlockAsm10B:
+        MOVL CX, SI
+        MOVL 12(SP), DI
+        CMPL DI, SI
+        JEQ  emit_literal_done_match_emit_encodeSnappyBlockAsm10B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(DI*1), SI
+        SUBL DI, R8
+        LEAL -1(R8), DI
+        CMPL DI, $0x3c
+        JB   one_byte_match_emit_encodeSnappyBlockAsm10B
+        CMPL DI, $0x00000100
+        JB   two_bytes_match_emit_encodeSnappyBlockAsm10B
+        JB   three_bytes_match_emit_encodeSnappyBlockAsm10B
+
+three_bytes_match_emit_encodeSnappyBlockAsm10B:
+        MOVB $0xf4, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeSnappyBlockAsm10B
+
+two_bytes_match_emit_encodeSnappyBlockAsm10B:
+        MOVB $0xf0, (AX)
+        MOVB DI, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DI, $0x40
+        JB   memmove_match_emit_encodeSnappyBlockAsm10B
+        JMP  memmove_long_match_emit_encodeSnappyBlockAsm10B
+
+one_byte_match_emit_encodeSnappyBlockAsm10B:
+        SHLB $0x02, DI
+        MOVB DI, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeSnappyBlockAsm10B:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm10B_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm10B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm10B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeSnappyBlockAsm10B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm10B_memmove_move_8:
+        MOVQ (SI), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBlockAsm10B
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm10B_memmove_move_8through16:
+        MOVQ (SI), R9
+        MOVQ -8(SI)(R8*1), SI
+        MOVQ R9, (AX)
+        MOVQ SI, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBlockAsm10B
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm10B_memmove_move_17through32:
+        MOVOU (SI), X0
+        MOVOU -16(SI)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeSnappyBlockAsm10B
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm10B_memmove_move_33through64:
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeSnappyBlockAsm10B:
+        MOVQ DI, AX
+        JMP  emit_literal_done_match_emit_encodeSnappyBlockAsm10B
+
+memmove_long_match_emit_encodeSnappyBlockAsm10B:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveLong
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVQ  R8, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm10Blarge_forward_sse_loop_32
+        LEAQ  -32(SI)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm10Blarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm10Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm10Blarge_forward_sse_loop_32:
+        MOVOU -32(SI)(R11*1), X4
+        MOVOU -16(SI)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  R8, R11
+        JAE   emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm10Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  DI, AX
+
+emit_literal_done_match_emit_encodeSnappyBlockAsm10B:
+match_nolit_loop_encodeSnappyBlockAsm10B:
+        MOVL CX, SI
+        SUBL BX, SI
+        MOVL SI, 16(SP)
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), SI
+        SUBL CX, SI
+        LEAQ (DX)(CX*1), DI
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R9, R9
+
+matchlen_loopback_16_match_nolit_encodeSnappyBlockAsm10B:
+        CMPL SI, $0x10
+        JB   matchlen_match8_match_nolit_encodeSnappyBlockAsm10B
+        MOVQ (DI)(R9*1), R8
+        MOVQ 8(DI)(R9*1), R10
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm10B
+        XORQ 8(BX)(R9*1), R10
+        JNZ  matchlen_bsf_16match_nolit_encodeSnappyBlockAsm10B
+        LEAL -16(SI), SI
+        LEAL 16(R9), R9
+        JMP  matchlen_loopback_16_match_nolit_encodeSnappyBlockAsm10B
+
+matchlen_bsf_16match_nolit_encodeSnappyBlockAsm10B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL 8(R9)(R10*1), R9
+        JMP  match_nolit_end_encodeSnappyBlockAsm10B
+
+matchlen_match8_match_nolit_encodeSnappyBlockAsm10B:
+        CMPL SI, $0x08
+        JB   matchlen_match4_match_nolit_encodeSnappyBlockAsm10B
+        MOVQ (DI)(R9*1), R8
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm10B
+        LEAL -8(SI), SI
+        LEAL 8(R9), R9
+        JMP  matchlen_match4_match_nolit_encodeSnappyBlockAsm10B
+
+matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm10B:
+#ifdef GOAMD64_v3
+        TZCNTQ R8, R8
+
+#else
+        BSFQ R8, R8
+
+#endif
+        SARQ $0x03, R8
+        LEAL (R9)(R8*1), R9
+        JMP  match_nolit_end_encodeSnappyBlockAsm10B
+
+matchlen_match4_match_nolit_encodeSnappyBlockAsm10B:
+        CMPL SI, $0x04
+        JB   matchlen_match2_match_nolit_encodeSnappyBlockAsm10B
+        MOVL (DI)(R9*1), R8
+        CMPL (BX)(R9*1), R8
+        JNE  matchlen_match2_match_nolit_encodeSnappyBlockAsm10B
+        LEAL -4(SI), SI
+        LEAL 4(R9), R9
+
+matchlen_match2_match_nolit_encodeSnappyBlockAsm10B:
+        CMPL SI, $0x01
+        JE   matchlen_match1_match_nolit_encodeSnappyBlockAsm10B
+        JB   match_nolit_end_encodeSnappyBlockAsm10B
+        MOVW (DI)(R9*1), R8
+        CMPW (BX)(R9*1), R8
+        JNE  matchlen_match1_match_nolit_encodeSnappyBlockAsm10B
+        LEAL 2(R9), R9
+        SUBL $0x02, SI
+        JZ   match_nolit_end_encodeSnappyBlockAsm10B
+
+matchlen_match1_match_nolit_encodeSnappyBlockAsm10B:
+        MOVB (DI)(R9*1), R8
+        CMPB (BX)(R9*1), R8
+        JNE  match_nolit_end_encodeSnappyBlockAsm10B
+        LEAL 1(R9), R9
+
+match_nolit_end_encodeSnappyBlockAsm10B:
+        ADDL R9, CX
+        MOVL 16(SP), BX
+        ADDL $0x04, R9
+        MOVL CX, 12(SP)
+
+        // emitCopy
+two_byte_offset_match_nolit_encodeSnappyBlockAsm10B:
+        CMPL R9, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeSnappyBlockAsm10B
+        MOVB $0xee, (AX)
+        MOVW BX, 1(AX)
+        LEAL -60(R9), R9
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_match_nolit_encodeSnappyBlockAsm10B
+
+two_byte_offset_short_match_nolit_encodeSnappyBlockAsm10B:
+        MOVL R9, SI
+        SHLL $0x02, SI
+        CMPL R9, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeSnappyBlockAsm10B
+        CMPL BX, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeSnappyBlockAsm10B
+        LEAL -15(SI), SI
+        MOVB BL, 1(AX)
+        SHRL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeSnappyBlockAsm10B
+
+emit_copy_three_match_nolit_encodeSnappyBlockAsm10B:
+        LEAL -2(SI), SI
+        MOVB SI, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeSnappyBlockAsm10B:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeSnappyBlockAsm10B
+        MOVQ -2(DX)(CX*1), SI
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeSnappyBlockAsm10B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeSnappyBlockAsm10B:
+        MOVQ  $0x9e3779b1, R8
+        MOVQ  SI, DI
+        SHRQ  $0x10, SI
+        MOVQ  SI, BX
+        SHLQ  $0x20, DI
+        IMULQ R8, DI
+        SHRQ  $0x36, DI
+        SHLQ  $0x20, BX
+        IMULQ R8, BX
+        SHRQ  $0x36, BX
+        LEAL  -2(CX), R8
+        LEAQ  24(SP)(BX*4), R9
+        MOVL  (R9), BX
+        MOVL  R8, 24(SP)(DI*4)
+        MOVL  CX, (R9)
+        CMPL  (DX)(BX*1), SI
+        JEQ   match_nolit_loop_encodeSnappyBlockAsm10B
+        INCL  CX
+        JMP   search_loop_encodeSnappyBlockAsm10B
+
+emit_remainder_encodeSnappyBlockAsm10B:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeSnappyBlockAsm10B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeSnappyBlockAsm10B:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeSnappyBlockAsm10B
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeSnappyBlockAsm10B
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeSnappyBlockAsm10B
+        JB   three_bytes_emit_remainder_encodeSnappyBlockAsm10B
+
+three_bytes_emit_remainder_encodeSnappyBlockAsm10B:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeSnappyBlockAsm10B
+
+two_bytes_emit_remainder_encodeSnappyBlockAsm10B:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeSnappyBlockAsm10B
+        JMP  memmove_long_emit_remainder_encodeSnappyBlockAsm10B
+
+one_byte_emit_remainder_encodeSnappyBlockAsm10B:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeSnappyBlockAsm10B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm10B_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm10B_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm10B_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm10B_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm10B_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm10B_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm10B_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm10B_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm10B_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm10B_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm10B_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeSnappyBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm10B_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeSnappyBlockAsm10B:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeSnappyBlockAsm10B
+
+memmove_long_emit_remainder_encodeSnappyBlockAsm10B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm10Blarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm10Blarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm10Blarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm10Blarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm10Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeSnappyBlockAsm10B:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeSnappyBlockAsm8B(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeSnappyBlockAsm8B(SB), $1048-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000008, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeSnappyBlockAsm8B:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeSnappyBlockAsm8B
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  CX, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeSnappyBlockAsm8B:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x04, BX
+        LEAL  4(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeSnappyBlockAsm8B
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x9e3779b1, R8
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHRQ  $0x08, R10
+        SHLQ  $0x20, R9
+        IMULQ R8, R9
+        SHRQ  $0x38, R9
+        SHLQ  $0x20, R10
+        IMULQ R8, R10
+        SHRQ  $0x38, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  24(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        LEAL  1(CX), R9
+        MOVL  R9, 24(SP)(R10*4)
+        MOVQ  SI, R9
+        SHRQ  $0x10, R9
+        SHLQ  $0x20, R9
+        IMULQ R8, R9
+        SHRQ  $0x38, R9
+        MOVL  CX, R8
+        SUBL  16(SP), R8
+        MOVL  1(DX)(R8*1), R10
+        MOVQ  SI, R8
+        SHRQ  $0x08, R8
+        CMPL  R8, R10
+        JNE   no_repeat_found_encodeSnappyBlockAsm8B
+        LEAL  1(CX), SI
+        MOVL  12(SP), BX
+        MOVL  SI, DI
+        SUBL  16(SP), DI
+        JZ    repeat_extend_back_end_encodeSnappyBlockAsm8B
+
+repeat_extend_back_loop_encodeSnappyBlockAsm8B:
+        CMPL SI, BX
+        JBE  repeat_extend_back_end_encodeSnappyBlockAsm8B
+        MOVB -1(DX)(DI*1), R8
+        MOVB -1(DX)(SI*1), R9
+        CMPB R8, R9
+        JNE  repeat_extend_back_end_encodeSnappyBlockAsm8B
+        LEAL -1(SI), SI
+        DECL DI
+        JNZ  repeat_extend_back_loop_encodeSnappyBlockAsm8B
+
+repeat_extend_back_end_encodeSnappyBlockAsm8B:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_repeat_emit_encodeSnappyBlockAsm8B
+        MOVL SI, DI
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R8
+        SUBL BX, DI
+        LEAL -1(DI), BX
+        CMPL BX, $0x3c
+        JB   one_byte_repeat_emit_encodeSnappyBlockAsm8B
+        CMPL BX, $0x00000100
+        JB   two_bytes_repeat_emit_encodeSnappyBlockAsm8B
+        JB   three_bytes_repeat_emit_encodeSnappyBlockAsm8B
+
+three_bytes_repeat_emit_encodeSnappyBlockAsm8B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_repeat_emit_encodeSnappyBlockAsm8B
+
+two_bytes_repeat_emit_encodeSnappyBlockAsm8B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_repeat_emit_encodeSnappyBlockAsm8B
+        JMP  memmove_long_repeat_emit_encodeSnappyBlockAsm8B
+
+one_byte_repeat_emit_encodeSnappyBlockAsm8B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_repeat_emit_encodeSnappyBlockAsm8B:
+        LEAQ (AX)(DI*1), BX
+
+        // genMemMoveShort
+        CMPQ DI, $0x08
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm8B_memmove_move_8
+        CMPQ DI, $0x10
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm8B_memmove_move_8through16
+        CMPQ DI, $0x20
+        JBE  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm8B_memmove_move_17through32
+        JMP  emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm8B_memmove_move_33through64
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm8B_memmove_move_8:
+        MOVQ (R8), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_repeat_emit_encodeSnappyBlockAsm8B
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm8B_memmove_move_8through16:
+        MOVQ (R8), R9
+        MOVQ -8(R8)(DI*1), R8
+        MOVQ R9, (AX)
+        MOVQ R8, -8(AX)(DI*1)
+        JMP  memmove_end_copy_repeat_emit_encodeSnappyBlockAsm8B
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm8B_memmove_move_17through32:
+        MOVOU (R8), X0
+        MOVOU -16(R8)(DI*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(DI*1)
+        JMP   memmove_end_copy_repeat_emit_encodeSnappyBlockAsm8B
+
+emit_lit_memmove_repeat_emit_encodeSnappyBlockAsm8B_memmove_move_33through64:
+        MOVOU (R8), X0
+        MOVOU 16(R8), X1
+        MOVOU -32(R8)(DI*1), X2
+        MOVOU -16(R8)(DI*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(DI*1)
+        MOVOU X3, -16(AX)(DI*1)
+
+memmove_end_copy_repeat_emit_encodeSnappyBlockAsm8B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_repeat_emit_encodeSnappyBlockAsm8B
+
+memmove_long_repeat_emit_encodeSnappyBlockAsm8B:
+        LEAQ (AX)(DI*1), BX
+
+        // genMemMoveLong
+        MOVOU (R8), X0
+        MOVOU 16(R8), X1
+        MOVOU -32(R8)(DI*1), X2
+        MOVOU -16(R8)(DI*1), X3
+        MOVQ  DI, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm8Blarge_forward_sse_loop_32
+        LEAQ  -32(R8)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm8Blarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm8Blarge_big_loop_back
+
+emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm8Blarge_forward_sse_loop_32:
+        MOVOU -32(R8)(R11*1), X4
+        MOVOU -16(R8)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  DI, R11
+        JAE   emit_lit_memmove_long_repeat_emit_encodeSnappyBlockAsm8Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(DI*1)
+        MOVOU X3, -16(AX)(DI*1)
+        MOVQ  BX, AX
+
+emit_literal_done_repeat_emit_encodeSnappyBlockAsm8B:
+        ADDL $0x05, CX
+        MOVL CX, BX
+        SUBL 16(SP), BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R10, R10
+
+matchlen_loopback_16_repeat_extend_encodeSnappyBlockAsm8B:
+        CMPL DI, $0x10
+        JB   matchlen_match8_repeat_extend_encodeSnappyBlockAsm8B
+        MOVQ (R8)(R10*1), R9
+        MOVQ 8(R8)(R10*1), R11
+        XORQ (BX)(R10*1), R9
+        JNZ  matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm8B
+        XORQ 8(BX)(R10*1), R11
+        JNZ  matchlen_bsf_16repeat_extend_encodeSnappyBlockAsm8B
+        LEAL -16(DI), DI
+        LEAL 16(R10), R10
+        JMP  matchlen_loopback_16_repeat_extend_encodeSnappyBlockAsm8B
+
+matchlen_bsf_16repeat_extend_encodeSnappyBlockAsm8B:
+#ifdef GOAMD64_v3
+        TZCNTQ R11, R11
+
+#else
+        BSFQ R11, R11
+
+#endif
+        SARQ $0x03, R11
+        LEAL 8(R10)(R11*1), R10
+        JMP  repeat_extend_forward_end_encodeSnappyBlockAsm8B
+
+matchlen_match8_repeat_extend_encodeSnappyBlockAsm8B:
+        CMPL DI, $0x08
+        JB   matchlen_match4_repeat_extend_encodeSnappyBlockAsm8B
+        MOVQ (R8)(R10*1), R9
+        XORQ (BX)(R10*1), R9
+        JNZ  matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm8B
+        LEAL -8(DI), DI
+        LEAL 8(R10), R10
+        JMP  matchlen_match4_repeat_extend_encodeSnappyBlockAsm8B
+
+matchlen_bsf_8_repeat_extend_encodeSnappyBlockAsm8B:
+#ifdef GOAMD64_v3
+        TZCNTQ R9, R9
+
+#else
+        BSFQ R9, R9
+
+#endif
+        SARQ $0x03, R9
+        LEAL (R10)(R9*1), R10
+        JMP  repeat_extend_forward_end_encodeSnappyBlockAsm8B
+
+matchlen_match4_repeat_extend_encodeSnappyBlockAsm8B:
+        CMPL DI, $0x04
+        JB   matchlen_match2_repeat_extend_encodeSnappyBlockAsm8B
+        MOVL (R8)(R10*1), R9
+        CMPL (BX)(R10*1), R9
+        JNE  matchlen_match2_repeat_extend_encodeSnappyBlockAsm8B
+        LEAL -4(DI), DI
+        LEAL 4(R10), R10
+
+matchlen_match2_repeat_extend_encodeSnappyBlockAsm8B:
+        CMPL DI, $0x01
+        JE   matchlen_match1_repeat_extend_encodeSnappyBlockAsm8B
+        JB   repeat_extend_forward_end_encodeSnappyBlockAsm8B
+        MOVW (R8)(R10*1), R9
+        CMPW (BX)(R10*1), R9
+        JNE  matchlen_match1_repeat_extend_encodeSnappyBlockAsm8B
+        LEAL 2(R10), R10
+        SUBL $0x02, DI
+        JZ   repeat_extend_forward_end_encodeSnappyBlockAsm8B
+
+matchlen_match1_repeat_extend_encodeSnappyBlockAsm8B:
+        MOVB (R8)(R10*1), R9
+        CMPB (BX)(R10*1), R9
+        JNE  repeat_extend_forward_end_encodeSnappyBlockAsm8B
+        LEAL 1(R10), R10
+
+repeat_extend_forward_end_encodeSnappyBlockAsm8B:
+        ADDL R10, CX
+        MOVL CX, BX
+        SUBL SI, BX
+        MOVL 16(SP), SI
+
+        // emitCopy
+two_byte_offset_repeat_as_copy_encodeSnappyBlockAsm8B:
+        CMPL BX, $0x40
+        JBE  two_byte_offset_short_repeat_as_copy_encodeSnappyBlockAsm8B
+        MOVB $0xee, (AX)
+        MOVW SI, 1(AX)
+        LEAL -60(BX), BX
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_repeat_as_copy_encodeSnappyBlockAsm8B
+
+two_byte_offset_short_repeat_as_copy_encodeSnappyBlockAsm8B:
+        MOVL BX, DI
+        SHLL $0x02, DI
+        CMPL BX, $0x0c
+        JAE  emit_copy_three_repeat_as_copy_encodeSnappyBlockAsm8B
+        LEAL -15(DI), DI
+        MOVB SI, 1(AX)
+        SHRL $0x08, SI
+        SHLL $0x05, SI
+        ORL  SI, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_encodeSnappyBlockAsm8B
+
+emit_copy_three_repeat_as_copy_encodeSnappyBlockAsm8B:
+        LEAL -2(DI), DI
+        MOVB DI, (AX)
+        MOVW SI, 1(AX)
+        ADDQ $0x03, AX
+
+repeat_end_emit_encodeSnappyBlockAsm8B:
+        MOVL CX, 12(SP)
+        JMP  search_loop_encodeSnappyBlockAsm8B
+
+no_repeat_found_encodeSnappyBlockAsm8B:
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate_match_encodeSnappyBlockAsm8B
+        SHRQ $0x08, SI
+        MOVL 24(SP)(R9*4), BX
+        LEAL 2(CX), R8
+        CMPL (DX)(DI*1), SI
+        JEQ  candidate2_match_encodeSnappyBlockAsm8B
+        MOVL R8, 24(SP)(R9*4)
+        SHRQ $0x08, SI
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate3_match_encodeSnappyBlockAsm8B
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeSnappyBlockAsm8B
+
+candidate3_match_encodeSnappyBlockAsm8B:
+        ADDL $0x02, CX
+        JMP  candidate_match_encodeSnappyBlockAsm8B
+
+candidate2_match_encodeSnappyBlockAsm8B:
+        MOVL R8, 24(SP)(R9*4)
+        INCL CX
+        MOVL DI, BX
+
+candidate_match_encodeSnappyBlockAsm8B:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeSnappyBlockAsm8B
+
+match_extend_back_loop_encodeSnappyBlockAsm8B:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeSnappyBlockAsm8B
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeSnappyBlockAsm8B
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeSnappyBlockAsm8B
+        JMP  match_extend_back_loop_encodeSnappyBlockAsm8B
+
+match_extend_back_end_encodeSnappyBlockAsm8B:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeSnappyBlockAsm8B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeSnappyBlockAsm8B:
+        MOVL CX, SI
+        MOVL 12(SP), DI
+        CMPL DI, SI
+        JEQ  emit_literal_done_match_emit_encodeSnappyBlockAsm8B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(DI*1), SI
+        SUBL DI, R8
+        LEAL -1(R8), DI
+        CMPL DI, $0x3c
+        JB   one_byte_match_emit_encodeSnappyBlockAsm8B
+        CMPL DI, $0x00000100
+        JB   two_bytes_match_emit_encodeSnappyBlockAsm8B
+        JB   three_bytes_match_emit_encodeSnappyBlockAsm8B
+
+three_bytes_match_emit_encodeSnappyBlockAsm8B:
+        MOVB $0xf4, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeSnappyBlockAsm8B
+
+two_bytes_match_emit_encodeSnappyBlockAsm8B:
+        MOVB $0xf0, (AX)
+        MOVB DI, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DI, $0x40
+        JB   memmove_match_emit_encodeSnappyBlockAsm8B
+        JMP  memmove_long_match_emit_encodeSnappyBlockAsm8B
+
+one_byte_match_emit_encodeSnappyBlockAsm8B:
+        SHLB $0x02, DI
+        MOVB DI, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeSnappyBlockAsm8B:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm8B_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm8B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBlockAsm8B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeSnappyBlockAsm8B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm8B_memmove_move_8:
+        MOVQ (SI), R9
+        MOVQ R9, (AX)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBlockAsm8B
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm8B_memmove_move_8through16:
+        MOVQ (SI), R9
+        MOVQ -8(SI)(R8*1), SI
+        MOVQ R9, (AX)
+        MOVQ SI, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBlockAsm8B
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm8B_memmove_move_17through32:
+        MOVOU (SI), X0
+        MOVOU -16(SI)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeSnappyBlockAsm8B
+
+emit_lit_memmove_match_emit_encodeSnappyBlockAsm8B_memmove_move_33through64:
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeSnappyBlockAsm8B:
+        MOVQ DI, AX
+        JMP  emit_literal_done_match_emit_encodeSnappyBlockAsm8B
+
+memmove_long_match_emit_encodeSnappyBlockAsm8B:
+        LEAQ (AX)(R8*1), DI
+
+        // genMemMoveLong
+        MOVOU (SI), X0
+        MOVOU 16(SI), X1
+        MOVOU -32(SI)(R8*1), X2
+        MOVOU -16(SI)(R8*1), X3
+        MOVQ  R8, R10
+        SHRQ  $0x05, R10
+        MOVQ  AX, R9
+        ANDL  $0x0000001f, R9
+        MOVQ  $0x00000040, R11
+        SUBQ  R9, R11
+        DECQ  R10
+        JA    emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm8Blarge_forward_sse_loop_32
+        LEAQ  -32(SI)(R11*1), R9
+        LEAQ  -32(AX)(R11*1), R12
+
+emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm8Blarge_big_loop_back:
+        MOVOU (R9), X4
+        MOVOU 16(R9), X5
+        MOVOA X4, (R12)
+        MOVOA X5, 16(R12)
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, R11
+        DECQ  R10
+        JNA   emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm8Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm8Blarge_forward_sse_loop_32:
+        MOVOU -32(SI)(R11*1), X4
+        MOVOU -16(SI)(R11*1), X5
+        MOVOA X4, -32(AX)(R11*1)
+        MOVOA X5, -16(AX)(R11*1)
+        ADDQ  $0x20, R11
+        CMPQ  R8, R11
+        JAE   emit_lit_memmove_long_match_emit_encodeSnappyBlockAsm8Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  DI, AX
+
+emit_literal_done_match_emit_encodeSnappyBlockAsm8B:
+match_nolit_loop_encodeSnappyBlockAsm8B:
+        MOVL CX, SI
+        SUBL BX, SI
+        MOVL SI, 16(SP)
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), SI
+        SUBL CX, SI
+        LEAQ (DX)(CX*1), DI
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R9, R9
+
+matchlen_loopback_16_match_nolit_encodeSnappyBlockAsm8B:
+        CMPL SI, $0x10
+        JB   matchlen_match8_match_nolit_encodeSnappyBlockAsm8B
+        MOVQ (DI)(R9*1), R8
+        MOVQ 8(DI)(R9*1), R10
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm8B
+        XORQ 8(BX)(R9*1), R10
+        JNZ  matchlen_bsf_16match_nolit_encodeSnappyBlockAsm8B
+        LEAL -16(SI), SI
+        LEAL 16(R9), R9
+        JMP  matchlen_loopback_16_match_nolit_encodeSnappyBlockAsm8B
+
+matchlen_bsf_16match_nolit_encodeSnappyBlockAsm8B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL 8(R9)(R10*1), R9
+        JMP  match_nolit_end_encodeSnappyBlockAsm8B
+
+matchlen_match8_match_nolit_encodeSnappyBlockAsm8B:
+        CMPL SI, $0x08
+        JB   matchlen_match4_match_nolit_encodeSnappyBlockAsm8B
+        MOVQ (DI)(R9*1), R8
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm8B
+        LEAL -8(SI), SI
+        LEAL 8(R9), R9
+        JMP  matchlen_match4_match_nolit_encodeSnappyBlockAsm8B
+
+matchlen_bsf_8_match_nolit_encodeSnappyBlockAsm8B:
+#ifdef GOAMD64_v3
+        TZCNTQ R8, R8
+
+#else
+        BSFQ R8, R8
+
+#endif
+        SARQ $0x03, R8
+        LEAL (R9)(R8*1), R9
+        JMP  match_nolit_end_encodeSnappyBlockAsm8B
+
+matchlen_match4_match_nolit_encodeSnappyBlockAsm8B:
+        CMPL SI, $0x04
+        JB   matchlen_match2_match_nolit_encodeSnappyBlockAsm8B
+        MOVL (DI)(R9*1), R8
+        CMPL (BX)(R9*1), R8
+        JNE  matchlen_match2_match_nolit_encodeSnappyBlockAsm8B
+        LEAL -4(SI), SI
+        LEAL 4(R9), R9
+
+matchlen_match2_match_nolit_encodeSnappyBlockAsm8B:
+        CMPL SI, $0x01
+        JE   matchlen_match1_match_nolit_encodeSnappyBlockAsm8B
+        JB   match_nolit_end_encodeSnappyBlockAsm8B
+        MOVW (DI)(R9*1), R8
+        CMPW (BX)(R9*1), R8
+        JNE  matchlen_match1_match_nolit_encodeSnappyBlockAsm8B
+        LEAL 2(R9), R9
+        SUBL $0x02, SI
+        JZ   match_nolit_end_encodeSnappyBlockAsm8B
+
+matchlen_match1_match_nolit_encodeSnappyBlockAsm8B:
+        MOVB (DI)(R9*1), R8
+        CMPB (BX)(R9*1), R8
+        JNE  match_nolit_end_encodeSnappyBlockAsm8B
+        LEAL 1(R9), R9
+
+match_nolit_end_encodeSnappyBlockAsm8B:
+        ADDL R9, CX
+        MOVL 16(SP), BX
+        ADDL $0x04, R9
+        MOVL CX, 12(SP)
+
+        // emitCopy
+two_byte_offset_match_nolit_encodeSnappyBlockAsm8B:
+        CMPL R9, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeSnappyBlockAsm8B
+        MOVB $0xee, (AX)
+        MOVW BX, 1(AX)
+        LEAL -60(R9), R9
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_match_nolit_encodeSnappyBlockAsm8B
+
+two_byte_offset_short_match_nolit_encodeSnappyBlockAsm8B:
+        MOVL R9, SI
+        SHLL $0x02, SI
+        CMPL R9, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeSnappyBlockAsm8B
+        LEAL -15(SI), SI
+        MOVB BL, 1(AX)
+        SHRL $0x08, BX
+        SHLL $0x05, BX
+        ORL  BX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeSnappyBlockAsm8B
+
+emit_copy_three_match_nolit_encodeSnappyBlockAsm8B:
+        LEAL -2(SI), SI
+        MOVB SI, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeSnappyBlockAsm8B:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeSnappyBlockAsm8B
+        MOVQ -2(DX)(CX*1), SI
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeSnappyBlockAsm8B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeSnappyBlockAsm8B:
+        MOVQ  $0x9e3779b1, R8
+        MOVQ  SI, DI
+        SHRQ  $0x10, SI
+        MOVQ  SI, BX
+        SHLQ  $0x20, DI
+        IMULQ R8, DI
+        SHRQ  $0x38, DI
+        SHLQ  $0x20, BX
+        IMULQ R8, BX
+        SHRQ  $0x38, BX
+        LEAL  -2(CX), R8
+        LEAQ  24(SP)(BX*4), R9
+        MOVL  (R9), BX
+        MOVL  R8, 24(SP)(DI*4)
+        MOVL  CX, (R9)
+        CMPL  (DX)(BX*1), SI
+        JEQ   match_nolit_loop_encodeSnappyBlockAsm8B
+        INCL  CX
+        JMP   search_loop_encodeSnappyBlockAsm8B
+
+emit_remainder_encodeSnappyBlockAsm8B:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeSnappyBlockAsm8B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeSnappyBlockAsm8B:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeSnappyBlockAsm8B
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeSnappyBlockAsm8B
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeSnappyBlockAsm8B
+        JB   three_bytes_emit_remainder_encodeSnappyBlockAsm8B
+
+three_bytes_emit_remainder_encodeSnappyBlockAsm8B:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeSnappyBlockAsm8B
+
+two_bytes_emit_remainder_encodeSnappyBlockAsm8B:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeSnappyBlockAsm8B
+        JMP  memmove_long_emit_remainder_encodeSnappyBlockAsm8B
+
+one_byte_emit_remainder_encodeSnappyBlockAsm8B:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeSnappyBlockAsm8B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm8B_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm8B_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm8B_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm8B_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm8B_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm8B_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm8B_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm8B_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm8B_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm8B_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm8B_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeSnappyBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBlockAsm8B_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeSnappyBlockAsm8B:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeSnappyBlockAsm8B
+
+memmove_long_emit_remainder_encodeSnappyBlockAsm8B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm8Blarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm8Blarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm8Blarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm8Blarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeSnappyBlockAsm8Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeSnappyBlockAsm8B:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeSnappyBetterBlockAsm(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeSnappyBetterBlockAsm(SB), $589848-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00001200, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeSnappyBetterBlockAsm:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeSnappyBetterBlockAsm
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  $0x00000000, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeSnappyBetterBlockAsm:
+        MOVL CX, BX
+        SUBL 12(SP), BX
+        SHRL $0x07, BX
+        CMPL BX, $0x63
+        JBE  check_maxskip_ok_encodeSnappyBetterBlockAsm
+        LEAL 100(CX), BX
+        JMP  check_maxskip_cont_encodeSnappyBetterBlockAsm
+
+check_maxskip_ok_encodeSnappyBetterBlockAsm:
+        LEAL 1(CX)(BX*1), BX
+
+check_maxskip_cont_encodeSnappyBetterBlockAsm:
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeSnappyBetterBlockAsm
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x00cf1bbcdcbfa563, R8
+        MOVQ  $0x9e3779b1, BX
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHLQ  $0x08, R9
+        IMULQ R8, R9
+        SHRQ  $0x2f, R9
+        SHLQ  $0x20, R10
+        IMULQ BX, R10
+        SHRQ  $0x32, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  524312(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        MOVL  CX, 524312(SP)(R10*4)
+        MOVQ  (DX)(BX*1), R9
+        MOVQ  (DX)(DI*1), R10
+        CMPQ  R9, SI
+        JEQ   candidate_match_encodeSnappyBetterBlockAsm
+        CMPQ  R10, SI
+        JNE   no_short_found_encodeSnappyBetterBlockAsm
+        MOVL  DI, BX
+        JMP   candidate_match_encodeSnappyBetterBlockAsm
+
+no_short_found_encodeSnappyBetterBlockAsm:
+        CMPL R9, SI
+        JEQ  candidate_match_encodeSnappyBetterBlockAsm
+        CMPL R10, SI
+        JEQ  candidateS_match_encodeSnappyBetterBlockAsm
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeSnappyBetterBlockAsm
+
+candidateS_match_encodeSnappyBetterBlockAsm:
+        SHRQ  $0x08, SI
+        MOVQ  SI, R9
+        SHLQ  $0x08, R9
+        IMULQ R8, R9
+        SHRQ  $0x2f, R9
+        MOVL  24(SP)(R9*4), BX
+        INCL  CX
+        MOVL  CX, 24(SP)(R9*4)
+        CMPL  (DX)(BX*1), SI
+        JEQ   candidate_match_encodeSnappyBetterBlockAsm
+        DECL  CX
+        MOVL  DI, BX
+
+candidate_match_encodeSnappyBetterBlockAsm:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeSnappyBetterBlockAsm
+
+match_extend_back_loop_encodeSnappyBetterBlockAsm:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeSnappyBetterBlockAsm
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeSnappyBetterBlockAsm
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeSnappyBetterBlockAsm
+        JMP  match_extend_back_loop_encodeSnappyBetterBlockAsm
+
+match_extend_back_end_encodeSnappyBetterBlockAsm:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 5(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeSnappyBetterBlockAsm
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeSnappyBetterBlockAsm:
+        MOVL CX, SI
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), R9
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_match_nolit_encodeSnappyBetterBlockAsm:
+        CMPL DI, $0x10
+        JB   matchlen_match8_match_nolit_encodeSnappyBetterBlockAsm
+        MOVQ (R8)(R11*1), R10
+        MOVQ 8(R8)(R11*1), R12
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm
+        XORQ 8(R9)(R11*1), R12
+        JNZ  matchlen_bsf_16match_nolit_encodeSnappyBetterBlockAsm
+        LEAL -16(DI), DI
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_match_nolit_encodeSnappyBetterBlockAsm
+
+matchlen_bsf_16match_nolit_encodeSnappyBetterBlockAsm:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  match_nolit_end_encodeSnappyBetterBlockAsm
+
+matchlen_match8_match_nolit_encodeSnappyBetterBlockAsm:
+        CMPL DI, $0x08
+        JB   matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm
+        MOVQ (R8)(R11*1), R10
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm
+        LEAL -8(DI), DI
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm
+
+matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  match_nolit_end_encodeSnappyBetterBlockAsm
+
+matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm:
+        CMPL DI, $0x04
+        JB   matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm
+        MOVL (R8)(R11*1), R10
+        CMPL (R9)(R11*1), R10
+        JNE  matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm
+        LEAL -4(DI), DI
+        LEAL 4(R11), R11
+
+matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm:
+        CMPL DI, $0x01
+        JE   matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm
+        JB   match_nolit_end_encodeSnappyBetterBlockAsm
+        MOVW (R8)(R11*1), R10
+        CMPW (R9)(R11*1), R10
+        JNE  matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm
+        LEAL 2(R11), R11
+        SUBL $0x02, DI
+        JZ   match_nolit_end_encodeSnappyBetterBlockAsm
+
+matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm:
+        MOVB (R8)(R11*1), R10
+        CMPB (R9)(R11*1), R10
+        JNE  match_nolit_end_encodeSnappyBetterBlockAsm
+        LEAL 1(R11), R11
+
+match_nolit_end_encodeSnappyBetterBlockAsm:
+        MOVL CX, DI
+        SUBL BX, DI
+
+        // Check if repeat
+        CMPL R11, $0x01
+        JA   match_length_ok_encodeSnappyBetterBlockAsm
+        CMPL DI, $0x0000ffff
+        JBE  match_length_ok_encodeSnappyBetterBlockAsm
+        MOVL 20(SP), CX
+        INCL CX
+        JMP  search_loop_encodeSnappyBetterBlockAsm
+
+match_length_ok_encodeSnappyBetterBlockAsm:
+        MOVL DI, 16(SP)
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_encodeSnappyBetterBlockAsm
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_encodeSnappyBetterBlockAsm
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_encodeSnappyBetterBlockAsm
+        CMPL BX, $0x00010000
+        JB   three_bytes_match_emit_encodeSnappyBetterBlockAsm
+        CMPL BX, $0x01000000
+        JB   four_bytes_match_emit_encodeSnappyBetterBlockAsm
+        MOVB $0xfc, (AX)
+        MOVL BX, 1(AX)
+        ADDQ $0x05, AX
+        JMP  memmove_long_match_emit_encodeSnappyBetterBlockAsm
+
+four_bytes_match_emit_encodeSnappyBetterBlockAsm:
+        MOVL BX, R10
+        SHRL $0x10, R10
+        MOVB $0xf8, (AX)
+        MOVW BX, 1(AX)
+        MOVB R10, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_match_emit_encodeSnappyBetterBlockAsm
+
+three_bytes_match_emit_encodeSnappyBetterBlockAsm:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeSnappyBetterBlockAsm
+
+two_bytes_match_emit_encodeSnappyBetterBlockAsm:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_encodeSnappyBetterBlockAsm
+        JMP  memmove_long_match_emit_encodeSnappyBetterBlockAsm
+
+one_byte_match_emit_encodeSnappyBetterBlockAsm:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeSnappyBetterBlockAsm:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm_memmove_move_8:
+        MOVQ (R9), R10
+        MOVQ R10, (AX)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_encodeSnappyBetterBlockAsm
+
+memmove_long_match_emit_encodeSnappyBetterBlockAsm:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R13
+        SUBQ  R10, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsmlarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R13*1), R10
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsmlarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsmlarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsmlarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R13*1), X4
+        MOVOU -16(R9)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsmlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_encodeSnappyBetterBlockAsm:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitCopy
+        CMPL DI, $0x00010000
+        JB   two_byte_offset_match_nolit_encodeSnappyBetterBlockAsm
+
+four_bytes_loop_back_match_nolit_encodeSnappyBetterBlockAsm:
+        CMPL R11, $0x40
+        JBE  four_bytes_remain_match_nolit_encodeSnappyBetterBlockAsm
+        MOVB $0xff, (AX)
+        MOVL DI, 1(AX)
+        LEAL -64(R11), R11
+        ADDQ $0x05, AX
+        CMPL R11, $0x04
+        JB   four_bytes_remain_match_nolit_encodeSnappyBetterBlockAsm
+        JMP  four_bytes_loop_back_match_nolit_encodeSnappyBetterBlockAsm
+
+four_bytes_remain_match_nolit_encodeSnappyBetterBlockAsm:
+        TESTL R11, R11
+        JZ    match_nolit_emitcopy_end_encodeSnappyBetterBlockAsm
+        XORL  BX, BX
+        LEAL  -1(BX)(R11*4), R11
+        MOVB  R11, (AX)
+        MOVL  DI, 1(AX)
+        ADDQ  $0x05, AX
+        JMP   match_nolit_emitcopy_end_encodeSnappyBetterBlockAsm
+
+two_byte_offset_match_nolit_encodeSnappyBetterBlockAsm:
+        CMPL R11, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeSnappyBetterBlockAsm
+        MOVB $0xee, (AX)
+        MOVW DI, 1(AX)
+        LEAL -60(R11), R11
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_match_nolit_encodeSnappyBetterBlockAsm
+
+two_byte_offset_short_match_nolit_encodeSnappyBetterBlockAsm:
+        MOVL R11, BX
+        SHLL $0x02, BX
+        CMPL R11, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeSnappyBetterBlockAsm
+        CMPL DI, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeSnappyBetterBlockAsm
+        LEAL -15(BX), BX
+        MOVB DI, 1(AX)
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeSnappyBetterBlockAsm
+
+emit_copy_three_match_nolit_encodeSnappyBetterBlockAsm:
+        LEAL -2(BX), BX
+        MOVB BL, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeSnappyBetterBlockAsm:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeSnappyBetterBlockAsm
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeSnappyBetterBlockAsm
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeSnappyBetterBlockAsm:
+        MOVQ  $0x00cf1bbcdcbfa563, BX
+        MOVQ  $0x9e3779b1, DI
+        LEAQ  1(SI), SI
+        LEAQ  -2(CX), R8
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  1(DX)(SI*1), R10
+        MOVQ  (DX)(R8*1), R11
+        MOVQ  1(DX)(R8*1), R12
+        SHLQ  $0x08, R9
+        IMULQ BX, R9
+        SHRQ  $0x2f, R9
+        SHLQ  $0x20, R10
+        IMULQ DI, R10
+        SHRQ  $0x32, R10
+        SHLQ  $0x08, R11
+        IMULQ BX, R11
+        SHRQ  $0x2f, R11
+        SHLQ  $0x20, R12
+        IMULQ DI, R12
+        SHRQ  $0x32, R12
+        LEAQ  1(SI), DI
+        LEAQ  1(R8), R13
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  R8, 24(SP)(R11*4)
+        MOVL  DI, 524312(SP)(R10*4)
+        MOVL  R13, 524312(SP)(R12*4)
+        LEAQ  1(R8)(SI*1), DI
+        SHRQ  $0x01, DI
+        ADDQ  $0x01, SI
+        SUBQ  $0x01, R8
+
+index_loop_encodeSnappyBetterBlockAsm:
+        CMPQ  DI, R8
+        JAE   search_loop_encodeSnappyBetterBlockAsm
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  (DX)(DI*1), R10
+        SHLQ  $0x08, R9
+        IMULQ BX, R9
+        SHRQ  $0x2f, R9
+        SHLQ  $0x08, R10
+        IMULQ BX, R10
+        SHRQ  $0x2f, R10
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  DI, 24(SP)(R10*4)
+        ADDQ  $0x02, SI
+        ADDQ  $0x02, DI
+        JMP   index_loop_encodeSnappyBetterBlockAsm
+
+emit_remainder_encodeSnappyBetterBlockAsm:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 5(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeSnappyBetterBlockAsm
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeSnappyBetterBlockAsm:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeSnappyBetterBlockAsm
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeSnappyBetterBlockAsm
+        CMPL DX, $0x00010000
+        JB   three_bytes_emit_remainder_encodeSnappyBetterBlockAsm
+        CMPL DX, $0x01000000
+        JB   four_bytes_emit_remainder_encodeSnappyBetterBlockAsm
+        MOVB $0xfc, (AX)
+        MOVL DX, 1(AX)
+        ADDQ $0x05, AX
+        JMP  memmove_long_emit_remainder_encodeSnappyBetterBlockAsm
+
+four_bytes_emit_remainder_encodeSnappyBetterBlockAsm:
+        MOVL DX, BX
+        SHRL $0x10, BX
+        MOVB $0xf8, (AX)
+        MOVW DX, 1(AX)
+        MOVB BL, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_emit_remainder_encodeSnappyBetterBlockAsm
+
+three_bytes_emit_remainder_encodeSnappyBetterBlockAsm:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeSnappyBetterBlockAsm
+
+two_bytes_emit_remainder_encodeSnappyBetterBlockAsm:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeSnappyBetterBlockAsm
+        JMP  memmove_long_emit_remainder_encodeSnappyBetterBlockAsm
+
+one_byte_emit_remainder_encodeSnappyBetterBlockAsm:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeSnappyBetterBlockAsm:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm
+
+memmove_long_emit_remainder_encodeSnappyBetterBlockAsm:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsmlarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsmlarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsmlarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsmlarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsmlarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeSnappyBetterBlockAsm64K(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeSnappyBetterBlockAsm64K(SB), $327704-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000a00, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeSnappyBetterBlockAsm64K:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeSnappyBetterBlockAsm64K
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  $0x00000000, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeSnappyBetterBlockAsm64K:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x07, BX
+        LEAL  1(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeSnappyBetterBlockAsm64K
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x00cf1bbcdcbfa563, R8
+        MOVQ  $0x9e3779b1, BX
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHLQ  $0x08, R9
+        IMULQ R8, R9
+        SHRQ  $0x30, R9
+        SHLQ  $0x20, R10
+        IMULQ BX, R10
+        SHRQ  $0x32, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  262168(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        MOVL  CX, 262168(SP)(R10*4)
+        MOVQ  (DX)(BX*1), R9
+        MOVQ  (DX)(DI*1), R10
+        CMPQ  R9, SI
+        JEQ   candidate_match_encodeSnappyBetterBlockAsm64K
+        CMPQ  R10, SI
+        JNE   no_short_found_encodeSnappyBetterBlockAsm64K
+        MOVL  DI, BX
+        JMP   candidate_match_encodeSnappyBetterBlockAsm64K
+
+no_short_found_encodeSnappyBetterBlockAsm64K:
+        CMPL R9, SI
+        JEQ  candidate_match_encodeSnappyBetterBlockAsm64K
+        CMPL R10, SI
+        JEQ  candidateS_match_encodeSnappyBetterBlockAsm64K
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeSnappyBetterBlockAsm64K
+
+candidateS_match_encodeSnappyBetterBlockAsm64K:
+        SHRQ  $0x08, SI
+        MOVQ  SI, R9
+        SHLQ  $0x08, R9
+        IMULQ R8, R9
+        SHRQ  $0x30, R9
+        MOVL  24(SP)(R9*4), BX
+        INCL  CX
+        MOVL  CX, 24(SP)(R9*4)
+        CMPL  (DX)(BX*1), SI
+        JEQ   candidate_match_encodeSnappyBetterBlockAsm64K
+        DECL  CX
+        MOVL  DI, BX
+
+candidate_match_encodeSnappyBetterBlockAsm64K:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeSnappyBetterBlockAsm64K
+
+match_extend_back_loop_encodeSnappyBetterBlockAsm64K:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeSnappyBetterBlockAsm64K
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeSnappyBetterBlockAsm64K
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeSnappyBetterBlockAsm64K
+        JMP  match_extend_back_loop_encodeSnappyBetterBlockAsm64K
+
+match_extend_back_end_encodeSnappyBetterBlockAsm64K:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeSnappyBetterBlockAsm64K
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeSnappyBetterBlockAsm64K:
+        MOVL CX, SI
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), R9
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_match_nolit_encodeSnappyBetterBlockAsm64K:
+        CMPL DI, $0x10
+        JB   matchlen_match8_match_nolit_encodeSnappyBetterBlockAsm64K
+        MOVQ (R8)(R11*1), R10
+        MOVQ 8(R8)(R11*1), R12
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm64K
+        XORQ 8(R9)(R11*1), R12
+        JNZ  matchlen_bsf_16match_nolit_encodeSnappyBetterBlockAsm64K
+        LEAL -16(DI), DI
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_match_nolit_encodeSnappyBetterBlockAsm64K
+
+matchlen_bsf_16match_nolit_encodeSnappyBetterBlockAsm64K:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  match_nolit_end_encodeSnappyBetterBlockAsm64K
+
+matchlen_match8_match_nolit_encodeSnappyBetterBlockAsm64K:
+        CMPL DI, $0x08
+        JB   matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm64K
+        MOVQ (R8)(R11*1), R10
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm64K
+        LEAL -8(DI), DI
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm64K
+
+matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm64K:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  match_nolit_end_encodeSnappyBetterBlockAsm64K
+
+matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm64K:
+        CMPL DI, $0x04
+        JB   matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm64K
+        MOVL (R8)(R11*1), R10
+        CMPL (R9)(R11*1), R10
+        JNE  matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm64K
+        LEAL -4(DI), DI
+        LEAL 4(R11), R11
+
+matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm64K:
+        CMPL DI, $0x01
+        JE   matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm64K
+        JB   match_nolit_end_encodeSnappyBetterBlockAsm64K
+        MOVW (R8)(R11*1), R10
+        CMPW (R9)(R11*1), R10
+        JNE  matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm64K
+        LEAL 2(R11), R11
+        SUBL $0x02, DI
+        JZ   match_nolit_end_encodeSnappyBetterBlockAsm64K
+
+matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm64K:
+        MOVB (R8)(R11*1), R10
+        CMPB (R9)(R11*1), R10
+        JNE  match_nolit_end_encodeSnappyBetterBlockAsm64K
+        LEAL 1(R11), R11
+
+match_nolit_end_encodeSnappyBetterBlockAsm64K:
+        MOVL CX, DI
+        SUBL BX, DI
+
+        // Check if repeat
+        MOVL DI, 16(SP)
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_encodeSnappyBetterBlockAsm64K
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_encodeSnappyBetterBlockAsm64K
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_encodeSnappyBetterBlockAsm64K
+        JB   three_bytes_match_emit_encodeSnappyBetterBlockAsm64K
+
+three_bytes_match_emit_encodeSnappyBetterBlockAsm64K:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeSnappyBetterBlockAsm64K
+
+two_bytes_match_emit_encodeSnappyBetterBlockAsm64K:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_encodeSnappyBetterBlockAsm64K
+        JMP  memmove_long_match_emit_encodeSnappyBetterBlockAsm64K
+
+one_byte_match_emit_encodeSnappyBetterBlockAsm64K:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeSnappyBetterBlockAsm64K:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm64K_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm64K_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm64K_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm64K_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm64K_memmove_move_8:
+        MOVQ (R9), R10
+        MOVQ R10, (AX)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm64K
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm64K_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm64K
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm64K_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm64K
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm64K_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm64K:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_encodeSnappyBetterBlockAsm64K
+
+memmove_long_match_emit_encodeSnappyBetterBlockAsm64K:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R13
+        SUBQ  R10, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm64Klarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R13*1), R10
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm64Klarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm64Klarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm64Klarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R13*1), X4
+        MOVOU -16(R9)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm64Klarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_encodeSnappyBetterBlockAsm64K:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitCopy
+two_byte_offset_match_nolit_encodeSnappyBetterBlockAsm64K:
+        CMPL R11, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeSnappyBetterBlockAsm64K
+        MOVB $0xee, (AX)
+        MOVW DI, 1(AX)
+        LEAL -60(R11), R11
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_match_nolit_encodeSnappyBetterBlockAsm64K
+
+two_byte_offset_short_match_nolit_encodeSnappyBetterBlockAsm64K:
+        MOVL R11, BX
+        SHLL $0x02, BX
+        CMPL R11, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeSnappyBetterBlockAsm64K
+        CMPL DI, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeSnappyBetterBlockAsm64K
+        LEAL -15(BX), BX
+        MOVB DI, 1(AX)
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeSnappyBetterBlockAsm64K
+
+emit_copy_three_match_nolit_encodeSnappyBetterBlockAsm64K:
+        LEAL -2(BX), BX
+        MOVB BL, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeSnappyBetterBlockAsm64K:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeSnappyBetterBlockAsm64K
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeSnappyBetterBlockAsm64K
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeSnappyBetterBlockAsm64K:
+        MOVQ  $0x00cf1bbcdcbfa563, BX
+        MOVQ  $0x9e3779b1, DI
+        LEAQ  1(SI), SI
+        LEAQ  -2(CX), R8
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  1(DX)(SI*1), R10
+        MOVQ  (DX)(R8*1), R11
+        MOVQ  1(DX)(R8*1), R12
+        SHLQ  $0x08, R9
+        IMULQ BX, R9
+        SHRQ  $0x30, R9
+        SHLQ  $0x20, R10
+        IMULQ DI, R10
+        SHRQ  $0x32, R10
+        SHLQ  $0x08, R11
+        IMULQ BX, R11
+        SHRQ  $0x30, R11
+        SHLQ  $0x20, R12
+        IMULQ DI, R12
+        SHRQ  $0x32, R12
+        LEAQ  1(SI), DI
+        LEAQ  1(R8), R13
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  R8, 24(SP)(R11*4)
+        MOVL  DI, 262168(SP)(R10*4)
+        MOVL  R13, 262168(SP)(R12*4)
+        LEAQ  1(R8)(SI*1), DI
+        SHRQ  $0x01, DI
+        ADDQ  $0x01, SI
+        SUBQ  $0x01, R8
+
+index_loop_encodeSnappyBetterBlockAsm64K:
+        CMPQ  DI, R8
+        JAE   search_loop_encodeSnappyBetterBlockAsm64K
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  (DX)(DI*1), R10
+        SHLQ  $0x08, R9
+        IMULQ BX, R9
+        SHRQ  $0x30, R9
+        SHLQ  $0x08, R10
+        IMULQ BX, R10
+        SHRQ  $0x30, R10
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  DI, 24(SP)(R10*4)
+        ADDQ  $0x02, SI
+        ADDQ  $0x02, DI
+        JMP   index_loop_encodeSnappyBetterBlockAsm64K
+
+emit_remainder_encodeSnappyBetterBlockAsm64K:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeSnappyBetterBlockAsm64K
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeSnappyBetterBlockAsm64K:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm64K
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeSnappyBetterBlockAsm64K
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeSnappyBetterBlockAsm64K
+        JB   three_bytes_emit_remainder_encodeSnappyBetterBlockAsm64K
+
+three_bytes_emit_remainder_encodeSnappyBetterBlockAsm64K:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeSnappyBetterBlockAsm64K
+
+two_bytes_emit_remainder_encodeSnappyBetterBlockAsm64K:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeSnappyBetterBlockAsm64K
+        JMP  memmove_long_emit_remainder_encodeSnappyBetterBlockAsm64K
+
+one_byte_emit_remainder_encodeSnappyBetterBlockAsm64K:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeSnappyBetterBlockAsm64K:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm64K_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm64K_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm64K_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm64K_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm64K_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm64K_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm64K_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm64K
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm64K_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm64K
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm64K_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm64K
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm64K_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm64K
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm64K_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm64K
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm64K_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm64K:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm64K
+
+memmove_long_emit_remainder_encodeSnappyBetterBlockAsm64K:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm64Klarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm64Klarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm64Klarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm64Klarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm64Klarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm64K:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeSnappyBetterBlockAsm12B(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeSnappyBetterBlockAsm12B(SB), $81944-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000280, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeSnappyBetterBlockAsm12B:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeSnappyBetterBlockAsm12B
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  $0x00000000, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeSnappyBetterBlockAsm12B:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x06, BX
+        LEAL  1(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeSnappyBetterBlockAsm12B
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  $0x9e3779b1, BX
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x32, R9
+        SHLQ  $0x20, R10
+        IMULQ BX, R10
+        SHRQ  $0x34, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  65560(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        MOVL  CX, 65560(SP)(R10*4)
+        MOVQ  (DX)(BX*1), R9
+        MOVQ  (DX)(DI*1), R10
+        CMPQ  R9, SI
+        JEQ   candidate_match_encodeSnappyBetterBlockAsm12B
+        CMPQ  R10, SI
+        JNE   no_short_found_encodeSnappyBetterBlockAsm12B
+        MOVL  DI, BX
+        JMP   candidate_match_encodeSnappyBetterBlockAsm12B
+
+no_short_found_encodeSnappyBetterBlockAsm12B:
+        CMPL R9, SI
+        JEQ  candidate_match_encodeSnappyBetterBlockAsm12B
+        CMPL R10, SI
+        JEQ  candidateS_match_encodeSnappyBetterBlockAsm12B
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeSnappyBetterBlockAsm12B
+
+candidateS_match_encodeSnappyBetterBlockAsm12B:
+        SHRQ  $0x08, SI
+        MOVQ  SI, R9
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x32, R9
+        MOVL  24(SP)(R9*4), BX
+        INCL  CX
+        MOVL  CX, 24(SP)(R9*4)
+        CMPL  (DX)(BX*1), SI
+        JEQ   candidate_match_encodeSnappyBetterBlockAsm12B
+        DECL  CX
+        MOVL  DI, BX
+
+candidate_match_encodeSnappyBetterBlockAsm12B:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeSnappyBetterBlockAsm12B
+
+match_extend_back_loop_encodeSnappyBetterBlockAsm12B:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeSnappyBetterBlockAsm12B
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeSnappyBetterBlockAsm12B
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeSnappyBetterBlockAsm12B
+        JMP  match_extend_back_loop_encodeSnappyBetterBlockAsm12B
+
+match_extend_back_end_encodeSnappyBetterBlockAsm12B:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeSnappyBetterBlockAsm12B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeSnappyBetterBlockAsm12B:
+        MOVL CX, SI
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), R9
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_match_nolit_encodeSnappyBetterBlockAsm12B:
+        CMPL DI, $0x10
+        JB   matchlen_match8_match_nolit_encodeSnappyBetterBlockAsm12B
+        MOVQ (R8)(R11*1), R10
+        MOVQ 8(R8)(R11*1), R12
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm12B
+        XORQ 8(R9)(R11*1), R12
+        JNZ  matchlen_bsf_16match_nolit_encodeSnappyBetterBlockAsm12B
+        LEAL -16(DI), DI
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_match_nolit_encodeSnappyBetterBlockAsm12B
+
+matchlen_bsf_16match_nolit_encodeSnappyBetterBlockAsm12B:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  match_nolit_end_encodeSnappyBetterBlockAsm12B
+
+matchlen_match8_match_nolit_encodeSnappyBetterBlockAsm12B:
+        CMPL DI, $0x08
+        JB   matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm12B
+        MOVQ (R8)(R11*1), R10
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm12B
+        LEAL -8(DI), DI
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm12B
+
+matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm12B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  match_nolit_end_encodeSnappyBetterBlockAsm12B
+
+matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm12B:
+        CMPL DI, $0x04
+        JB   matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm12B
+        MOVL (R8)(R11*1), R10
+        CMPL (R9)(R11*1), R10
+        JNE  matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm12B
+        LEAL -4(DI), DI
+        LEAL 4(R11), R11
+
+matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm12B:
+        CMPL DI, $0x01
+        JE   matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm12B
+        JB   match_nolit_end_encodeSnappyBetterBlockAsm12B
+        MOVW (R8)(R11*1), R10
+        CMPW (R9)(R11*1), R10
+        JNE  matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm12B
+        LEAL 2(R11), R11
+        SUBL $0x02, DI
+        JZ   match_nolit_end_encodeSnappyBetterBlockAsm12B
+
+matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm12B:
+        MOVB (R8)(R11*1), R10
+        CMPB (R9)(R11*1), R10
+        JNE  match_nolit_end_encodeSnappyBetterBlockAsm12B
+        LEAL 1(R11), R11
+
+match_nolit_end_encodeSnappyBetterBlockAsm12B:
+        MOVL CX, DI
+        SUBL BX, DI
+
+        // Check if repeat
+        MOVL DI, 16(SP)
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_encodeSnappyBetterBlockAsm12B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_encodeSnappyBetterBlockAsm12B
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_encodeSnappyBetterBlockAsm12B
+        JB   three_bytes_match_emit_encodeSnappyBetterBlockAsm12B
+
+three_bytes_match_emit_encodeSnappyBetterBlockAsm12B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeSnappyBetterBlockAsm12B
+
+two_bytes_match_emit_encodeSnappyBetterBlockAsm12B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_encodeSnappyBetterBlockAsm12B
+        JMP  memmove_long_match_emit_encodeSnappyBetterBlockAsm12B
+
+one_byte_match_emit_encodeSnappyBetterBlockAsm12B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeSnappyBetterBlockAsm12B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm12B_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm12B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm12B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm12B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm12B_memmove_move_8:
+        MOVQ (R9), R10
+        MOVQ R10, (AX)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm12B
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm12B_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm12B
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm12B_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm12B
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm12B_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm12B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_encodeSnappyBetterBlockAsm12B
+
+memmove_long_match_emit_encodeSnappyBetterBlockAsm12B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R13
+        SUBQ  R10, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm12Blarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R13*1), R10
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm12Blarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm12Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm12Blarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R13*1), X4
+        MOVOU -16(R9)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm12Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_encodeSnappyBetterBlockAsm12B:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitCopy
+two_byte_offset_match_nolit_encodeSnappyBetterBlockAsm12B:
+        CMPL R11, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeSnappyBetterBlockAsm12B
+        MOVB $0xee, (AX)
+        MOVW DI, 1(AX)
+        LEAL -60(R11), R11
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_match_nolit_encodeSnappyBetterBlockAsm12B
+
+two_byte_offset_short_match_nolit_encodeSnappyBetterBlockAsm12B:
+        MOVL R11, BX
+        SHLL $0x02, BX
+        CMPL R11, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeSnappyBetterBlockAsm12B
+        CMPL DI, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeSnappyBetterBlockAsm12B
+        LEAL -15(BX), BX
+        MOVB DI, 1(AX)
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeSnappyBetterBlockAsm12B
+
+emit_copy_three_match_nolit_encodeSnappyBetterBlockAsm12B:
+        LEAL -2(BX), BX
+        MOVB BL, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeSnappyBetterBlockAsm12B:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeSnappyBetterBlockAsm12B
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeSnappyBetterBlockAsm12B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeSnappyBetterBlockAsm12B:
+        MOVQ  $0x0000cf1bbcdcbf9b, BX
+        MOVQ  $0x9e3779b1, DI
+        LEAQ  1(SI), SI
+        LEAQ  -2(CX), R8
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  1(DX)(SI*1), R10
+        MOVQ  (DX)(R8*1), R11
+        MOVQ  1(DX)(R8*1), R12
+        SHLQ  $0x10, R9
+        IMULQ BX, R9
+        SHRQ  $0x32, R9
+        SHLQ  $0x20, R10
+        IMULQ DI, R10
+        SHRQ  $0x34, R10
+        SHLQ  $0x10, R11
+        IMULQ BX, R11
+        SHRQ  $0x32, R11
+        SHLQ  $0x20, R12
+        IMULQ DI, R12
+        SHRQ  $0x34, R12
+        LEAQ  1(SI), DI
+        LEAQ  1(R8), R13
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  R8, 24(SP)(R11*4)
+        MOVL  DI, 65560(SP)(R10*4)
+        MOVL  R13, 65560(SP)(R12*4)
+        LEAQ  1(R8)(SI*1), DI
+        SHRQ  $0x01, DI
+        ADDQ  $0x01, SI
+        SUBQ  $0x01, R8
+
+index_loop_encodeSnappyBetterBlockAsm12B:
+        CMPQ  DI, R8
+        JAE   search_loop_encodeSnappyBetterBlockAsm12B
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  (DX)(DI*1), R10
+        SHLQ  $0x10, R9
+        IMULQ BX, R9
+        SHRQ  $0x32, R9
+        SHLQ  $0x10, R10
+        IMULQ BX, R10
+        SHRQ  $0x32, R10
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  DI, 24(SP)(R10*4)
+        ADDQ  $0x02, SI
+        ADDQ  $0x02, DI
+        JMP   index_loop_encodeSnappyBetterBlockAsm12B
+
+emit_remainder_encodeSnappyBetterBlockAsm12B:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeSnappyBetterBlockAsm12B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeSnappyBetterBlockAsm12B:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm12B
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeSnappyBetterBlockAsm12B
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeSnappyBetterBlockAsm12B
+        JB   three_bytes_emit_remainder_encodeSnappyBetterBlockAsm12B
+
+three_bytes_emit_remainder_encodeSnappyBetterBlockAsm12B:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeSnappyBetterBlockAsm12B
+
+two_bytes_emit_remainder_encodeSnappyBetterBlockAsm12B:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeSnappyBetterBlockAsm12B
+        JMP  memmove_long_emit_remainder_encodeSnappyBetterBlockAsm12B
+
+one_byte_emit_remainder_encodeSnappyBetterBlockAsm12B:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeSnappyBetterBlockAsm12B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm12B_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm12B_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm12B_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm12B_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm12B_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm12B_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm12B_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm12B_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm12B_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm12B_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm12B_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm12B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm12B_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm12B:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm12B
+
+memmove_long_emit_remainder_encodeSnappyBetterBlockAsm12B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm12Blarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm12Blarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm12Blarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm12Blarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm12Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm12B:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeSnappyBetterBlockAsm10B(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeSnappyBetterBlockAsm10B(SB), $20504-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x000000a0, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeSnappyBetterBlockAsm10B:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeSnappyBetterBlockAsm10B
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  $0x00000000, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeSnappyBetterBlockAsm10B:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x05, BX
+        LEAL  1(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeSnappyBetterBlockAsm10B
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  $0x9e3779b1, BX
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x34, R9
+        SHLQ  $0x20, R10
+        IMULQ BX, R10
+        SHRQ  $0x36, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  16408(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        MOVL  CX, 16408(SP)(R10*4)
+        MOVQ  (DX)(BX*1), R9
+        MOVQ  (DX)(DI*1), R10
+        CMPQ  R9, SI
+        JEQ   candidate_match_encodeSnappyBetterBlockAsm10B
+        CMPQ  R10, SI
+        JNE   no_short_found_encodeSnappyBetterBlockAsm10B
+        MOVL  DI, BX
+        JMP   candidate_match_encodeSnappyBetterBlockAsm10B
+
+no_short_found_encodeSnappyBetterBlockAsm10B:
+        CMPL R9, SI
+        JEQ  candidate_match_encodeSnappyBetterBlockAsm10B
+        CMPL R10, SI
+        JEQ  candidateS_match_encodeSnappyBetterBlockAsm10B
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeSnappyBetterBlockAsm10B
+
+candidateS_match_encodeSnappyBetterBlockAsm10B:
+        SHRQ  $0x08, SI
+        MOVQ  SI, R9
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x34, R9
+        MOVL  24(SP)(R9*4), BX
+        INCL  CX
+        MOVL  CX, 24(SP)(R9*4)
+        CMPL  (DX)(BX*1), SI
+        JEQ   candidate_match_encodeSnappyBetterBlockAsm10B
+        DECL  CX
+        MOVL  DI, BX
+
+candidate_match_encodeSnappyBetterBlockAsm10B:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeSnappyBetterBlockAsm10B
+
+match_extend_back_loop_encodeSnappyBetterBlockAsm10B:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeSnappyBetterBlockAsm10B
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeSnappyBetterBlockAsm10B
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeSnappyBetterBlockAsm10B
+        JMP  match_extend_back_loop_encodeSnappyBetterBlockAsm10B
+
+match_extend_back_end_encodeSnappyBetterBlockAsm10B:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeSnappyBetterBlockAsm10B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeSnappyBetterBlockAsm10B:
+        MOVL CX, SI
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), R9
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_match_nolit_encodeSnappyBetterBlockAsm10B:
+        CMPL DI, $0x10
+        JB   matchlen_match8_match_nolit_encodeSnappyBetterBlockAsm10B
+        MOVQ (R8)(R11*1), R10
+        MOVQ 8(R8)(R11*1), R12
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm10B
+        XORQ 8(R9)(R11*1), R12
+        JNZ  matchlen_bsf_16match_nolit_encodeSnappyBetterBlockAsm10B
+        LEAL -16(DI), DI
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_match_nolit_encodeSnappyBetterBlockAsm10B
+
+matchlen_bsf_16match_nolit_encodeSnappyBetterBlockAsm10B:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  match_nolit_end_encodeSnappyBetterBlockAsm10B
+
+matchlen_match8_match_nolit_encodeSnappyBetterBlockAsm10B:
+        CMPL DI, $0x08
+        JB   matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm10B
+        MOVQ (R8)(R11*1), R10
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm10B
+        LEAL -8(DI), DI
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm10B
+
+matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm10B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  match_nolit_end_encodeSnappyBetterBlockAsm10B
+
+matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm10B:
+        CMPL DI, $0x04
+        JB   matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm10B
+        MOVL (R8)(R11*1), R10
+        CMPL (R9)(R11*1), R10
+        JNE  matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm10B
+        LEAL -4(DI), DI
+        LEAL 4(R11), R11
+
+matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm10B:
+        CMPL DI, $0x01
+        JE   matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm10B
+        JB   match_nolit_end_encodeSnappyBetterBlockAsm10B
+        MOVW (R8)(R11*1), R10
+        CMPW (R9)(R11*1), R10
+        JNE  matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm10B
+        LEAL 2(R11), R11
+        SUBL $0x02, DI
+        JZ   match_nolit_end_encodeSnappyBetterBlockAsm10B
+
+matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm10B:
+        MOVB (R8)(R11*1), R10
+        CMPB (R9)(R11*1), R10
+        JNE  match_nolit_end_encodeSnappyBetterBlockAsm10B
+        LEAL 1(R11), R11
+
+match_nolit_end_encodeSnappyBetterBlockAsm10B:
+        MOVL CX, DI
+        SUBL BX, DI
+
+        // Check if repeat
+        MOVL DI, 16(SP)
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_encodeSnappyBetterBlockAsm10B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_encodeSnappyBetterBlockAsm10B
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_encodeSnappyBetterBlockAsm10B
+        JB   three_bytes_match_emit_encodeSnappyBetterBlockAsm10B
+
+three_bytes_match_emit_encodeSnappyBetterBlockAsm10B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeSnappyBetterBlockAsm10B
+
+two_bytes_match_emit_encodeSnappyBetterBlockAsm10B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_encodeSnappyBetterBlockAsm10B
+        JMP  memmove_long_match_emit_encodeSnappyBetterBlockAsm10B
+
+one_byte_match_emit_encodeSnappyBetterBlockAsm10B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeSnappyBetterBlockAsm10B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm10B_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm10B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm10B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm10B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm10B_memmove_move_8:
+        MOVQ (R9), R10
+        MOVQ R10, (AX)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm10B
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm10B_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm10B
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm10B_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm10B
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm10B_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm10B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_encodeSnappyBetterBlockAsm10B
+
+memmove_long_match_emit_encodeSnappyBetterBlockAsm10B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R13
+        SUBQ  R10, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm10Blarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R13*1), R10
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm10Blarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm10Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm10Blarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R13*1), X4
+        MOVOU -16(R9)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm10Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_encodeSnappyBetterBlockAsm10B:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitCopy
+two_byte_offset_match_nolit_encodeSnappyBetterBlockAsm10B:
+        CMPL R11, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeSnappyBetterBlockAsm10B
+        MOVB $0xee, (AX)
+        MOVW DI, 1(AX)
+        LEAL -60(R11), R11
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_match_nolit_encodeSnappyBetterBlockAsm10B
+
+two_byte_offset_short_match_nolit_encodeSnappyBetterBlockAsm10B:
+        MOVL R11, BX
+        SHLL $0x02, BX
+        CMPL R11, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeSnappyBetterBlockAsm10B
+        CMPL DI, $0x00000800
+        JAE  emit_copy_three_match_nolit_encodeSnappyBetterBlockAsm10B
+        LEAL -15(BX), BX
+        MOVB DI, 1(AX)
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeSnappyBetterBlockAsm10B
+
+emit_copy_three_match_nolit_encodeSnappyBetterBlockAsm10B:
+        LEAL -2(BX), BX
+        MOVB BL, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeSnappyBetterBlockAsm10B:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeSnappyBetterBlockAsm10B
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeSnappyBetterBlockAsm10B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeSnappyBetterBlockAsm10B:
+        MOVQ  $0x0000cf1bbcdcbf9b, BX
+        MOVQ  $0x9e3779b1, DI
+        LEAQ  1(SI), SI
+        LEAQ  -2(CX), R8
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  1(DX)(SI*1), R10
+        MOVQ  (DX)(R8*1), R11
+        MOVQ  1(DX)(R8*1), R12
+        SHLQ  $0x10, R9
+        IMULQ BX, R9
+        SHRQ  $0x34, R9
+        SHLQ  $0x20, R10
+        IMULQ DI, R10
+        SHRQ  $0x36, R10
+        SHLQ  $0x10, R11
+        IMULQ BX, R11
+        SHRQ  $0x34, R11
+        SHLQ  $0x20, R12
+        IMULQ DI, R12
+        SHRQ  $0x36, R12
+        LEAQ  1(SI), DI
+        LEAQ  1(R8), R13
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  R8, 24(SP)(R11*4)
+        MOVL  DI, 16408(SP)(R10*4)
+        MOVL  R13, 16408(SP)(R12*4)
+        LEAQ  1(R8)(SI*1), DI
+        SHRQ  $0x01, DI
+        ADDQ  $0x01, SI
+        SUBQ  $0x01, R8
+
+index_loop_encodeSnappyBetterBlockAsm10B:
+        CMPQ  DI, R8
+        JAE   search_loop_encodeSnappyBetterBlockAsm10B
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  (DX)(DI*1), R10
+        SHLQ  $0x10, R9
+        IMULQ BX, R9
+        SHRQ  $0x34, R9
+        SHLQ  $0x10, R10
+        IMULQ BX, R10
+        SHRQ  $0x34, R10
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  DI, 24(SP)(R10*4)
+        ADDQ  $0x02, SI
+        ADDQ  $0x02, DI
+        JMP   index_loop_encodeSnappyBetterBlockAsm10B
+
+emit_remainder_encodeSnappyBetterBlockAsm10B:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeSnappyBetterBlockAsm10B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeSnappyBetterBlockAsm10B:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm10B
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeSnappyBetterBlockAsm10B
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeSnappyBetterBlockAsm10B
+        JB   three_bytes_emit_remainder_encodeSnappyBetterBlockAsm10B
+
+three_bytes_emit_remainder_encodeSnappyBetterBlockAsm10B:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeSnappyBetterBlockAsm10B
+
+two_bytes_emit_remainder_encodeSnappyBetterBlockAsm10B:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeSnappyBetterBlockAsm10B
+        JMP  memmove_long_emit_remainder_encodeSnappyBetterBlockAsm10B
+
+one_byte_emit_remainder_encodeSnappyBetterBlockAsm10B:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeSnappyBetterBlockAsm10B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm10B_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm10B_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm10B_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm10B_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm10B_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm10B_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm10B_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm10B_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm10B_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm10B_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm10B_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm10B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm10B_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm10B:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm10B
+
+memmove_long_emit_remainder_encodeSnappyBetterBlockAsm10B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm10Blarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm10Blarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm10Blarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm10Blarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm10Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm10B:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func encodeSnappyBetterBlockAsm8B(dst []byte, src []byte) int
+// Requires: BMI, SSE2
+TEXT ·encodeSnappyBetterBlockAsm8B(SB), $5144-56
+        MOVQ dst_base+0(FP), AX
+        MOVQ $0x00000028, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_encodeSnappyBetterBlockAsm8B:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_encodeSnappyBetterBlockAsm8B
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+32(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  $0x00000000, 16(SP)
+        MOVQ  src_base+24(FP), DX
+
+search_loop_encodeSnappyBetterBlockAsm8B:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x04, BX
+        LEAL  1(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_encodeSnappyBetterBlockAsm8B
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  $0x9e3779b1, BX
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x36, R9
+        SHLQ  $0x20, R10
+        IMULQ BX, R10
+        SHRQ  $0x38, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  4120(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        MOVL  CX, 4120(SP)(R10*4)
+        MOVQ  (DX)(BX*1), R9
+        MOVQ  (DX)(DI*1), R10
+        CMPQ  R9, SI
+        JEQ   candidate_match_encodeSnappyBetterBlockAsm8B
+        CMPQ  R10, SI
+        JNE   no_short_found_encodeSnappyBetterBlockAsm8B
+        MOVL  DI, BX
+        JMP   candidate_match_encodeSnappyBetterBlockAsm8B
+
+no_short_found_encodeSnappyBetterBlockAsm8B:
+        CMPL R9, SI
+        JEQ  candidate_match_encodeSnappyBetterBlockAsm8B
+        CMPL R10, SI
+        JEQ  candidateS_match_encodeSnappyBetterBlockAsm8B
+        MOVL 20(SP), CX
+        JMP  search_loop_encodeSnappyBetterBlockAsm8B
+
+candidateS_match_encodeSnappyBetterBlockAsm8B:
+        SHRQ  $0x08, SI
+        MOVQ  SI, R9
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x36, R9
+        MOVL  24(SP)(R9*4), BX
+        INCL  CX
+        MOVL  CX, 24(SP)(R9*4)
+        CMPL  (DX)(BX*1), SI
+        JEQ   candidate_match_encodeSnappyBetterBlockAsm8B
+        DECL  CX
+        MOVL  DI, BX
+
+candidate_match_encodeSnappyBetterBlockAsm8B:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_encodeSnappyBetterBlockAsm8B
+
+match_extend_back_loop_encodeSnappyBetterBlockAsm8B:
+        CMPL CX, SI
+        JBE  match_extend_back_end_encodeSnappyBetterBlockAsm8B
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_encodeSnappyBetterBlockAsm8B
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_encodeSnappyBetterBlockAsm8B
+        JMP  match_extend_back_loop_encodeSnappyBetterBlockAsm8B
+
+match_extend_back_end_encodeSnappyBetterBlockAsm8B:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_encodeSnappyBetterBlockAsm8B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_dst_size_check_encodeSnappyBetterBlockAsm8B:
+        MOVL CX, SI
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+32(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), R9
+
+        // matchLen
+        XORL R11, R11
+
+matchlen_loopback_16_match_nolit_encodeSnappyBetterBlockAsm8B:
+        CMPL DI, $0x10
+        JB   matchlen_match8_match_nolit_encodeSnappyBetterBlockAsm8B
+        MOVQ (R8)(R11*1), R10
+        MOVQ 8(R8)(R11*1), R12
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm8B
+        XORQ 8(R9)(R11*1), R12
+        JNZ  matchlen_bsf_16match_nolit_encodeSnappyBetterBlockAsm8B
+        LEAL -16(DI), DI
+        LEAL 16(R11), R11
+        JMP  matchlen_loopback_16_match_nolit_encodeSnappyBetterBlockAsm8B
+
+matchlen_bsf_16match_nolit_encodeSnappyBetterBlockAsm8B:
+#ifdef GOAMD64_v3
+        TZCNTQ R12, R12
+
+#else
+        BSFQ R12, R12
+
+#endif
+        SARQ $0x03, R12
+        LEAL 8(R11)(R12*1), R11
+        JMP  match_nolit_end_encodeSnappyBetterBlockAsm8B
+
+matchlen_match8_match_nolit_encodeSnappyBetterBlockAsm8B:
+        CMPL DI, $0x08
+        JB   matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm8B
+        MOVQ (R8)(R11*1), R10
+        XORQ (R9)(R11*1), R10
+        JNZ  matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm8B
+        LEAL -8(DI), DI
+        LEAL 8(R11), R11
+        JMP  matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm8B
+
+matchlen_bsf_8_match_nolit_encodeSnappyBetterBlockAsm8B:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL (R11)(R10*1), R11
+        JMP  match_nolit_end_encodeSnappyBetterBlockAsm8B
+
+matchlen_match4_match_nolit_encodeSnappyBetterBlockAsm8B:
+        CMPL DI, $0x04
+        JB   matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm8B
+        MOVL (R8)(R11*1), R10
+        CMPL (R9)(R11*1), R10
+        JNE  matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm8B
+        LEAL -4(DI), DI
+        LEAL 4(R11), R11
+
+matchlen_match2_match_nolit_encodeSnappyBetterBlockAsm8B:
+        CMPL DI, $0x01
+        JE   matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm8B
+        JB   match_nolit_end_encodeSnappyBetterBlockAsm8B
+        MOVW (R8)(R11*1), R10
+        CMPW (R9)(R11*1), R10
+        JNE  matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm8B
+        LEAL 2(R11), R11
+        SUBL $0x02, DI
+        JZ   match_nolit_end_encodeSnappyBetterBlockAsm8B
+
+matchlen_match1_match_nolit_encodeSnappyBetterBlockAsm8B:
+        MOVB (R8)(R11*1), R10
+        CMPB (R9)(R11*1), R10
+        JNE  match_nolit_end_encodeSnappyBetterBlockAsm8B
+        LEAL 1(R11), R11
+
+match_nolit_end_encodeSnappyBetterBlockAsm8B:
+        MOVL CX, DI
+        SUBL BX, DI
+
+        // Check if repeat
+        MOVL DI, 16(SP)
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_match_emit_encodeSnappyBetterBlockAsm8B
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R9
+        SUBL BX, R8
+        LEAL -1(R8), BX
+        CMPL BX, $0x3c
+        JB   one_byte_match_emit_encodeSnappyBetterBlockAsm8B
+        CMPL BX, $0x00000100
+        JB   two_bytes_match_emit_encodeSnappyBetterBlockAsm8B
+        JB   three_bytes_match_emit_encodeSnappyBetterBlockAsm8B
+
+three_bytes_match_emit_encodeSnappyBetterBlockAsm8B:
+        MOVB $0xf4, (AX)
+        MOVW BX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_encodeSnappyBetterBlockAsm8B
+
+two_bytes_match_emit_encodeSnappyBetterBlockAsm8B:
+        MOVB $0xf0, (AX)
+        MOVB BL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_match_emit_encodeSnappyBetterBlockAsm8B
+        JMP  memmove_long_match_emit_encodeSnappyBetterBlockAsm8B
+
+one_byte_match_emit_encodeSnappyBetterBlockAsm8B:
+        SHLB $0x02, BL
+        MOVB BL, (AX)
+        ADDQ $0x01, AX
+
+memmove_match_emit_encodeSnappyBetterBlockAsm8B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm8B_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm8B_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm8B_memmove_move_17through32
+        JMP  emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm8B_memmove_move_33through64
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm8B_memmove_move_8:
+        MOVQ (R9), R10
+        MOVQ R10, (AX)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm8B
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm8B_memmove_move_8through16:
+        MOVQ (R9), R10
+        MOVQ -8(R9)(R8*1), R9
+        MOVQ R10, (AX)
+        MOVQ R9, -8(AX)(R8*1)
+        JMP  memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm8B
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm8B_memmove_move_17through32:
+        MOVOU (R9), X0
+        MOVOU -16(R9)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm8B
+
+emit_lit_memmove_match_emit_encodeSnappyBetterBlockAsm8B_memmove_move_33through64:
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_match_emit_encodeSnappyBetterBlockAsm8B:
+        MOVQ BX, AX
+        JMP  emit_literal_done_match_emit_encodeSnappyBetterBlockAsm8B
+
+memmove_long_match_emit_encodeSnappyBetterBlockAsm8B:
+        LEAQ (AX)(R8*1), BX
+
+        // genMemMoveLong
+        MOVOU (R9), X0
+        MOVOU 16(R9), X1
+        MOVOU -32(R9)(R8*1), X2
+        MOVOU -16(R9)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R10
+        ANDL  $0x0000001f, R10
+        MOVQ  $0x00000040, R13
+        SUBQ  R10, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm8Blarge_forward_sse_loop_32
+        LEAQ  -32(R9)(R13*1), R10
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm8Blarge_big_loop_back:
+        MOVOU (R10), X4
+        MOVOU 16(R10), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R10
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm8Blarge_big_loop_back
+
+emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm8Blarge_forward_sse_loop_32:
+        MOVOU -32(R9)(R13*1), X4
+        MOVOU -16(R9)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_match_emit_encodeSnappyBetterBlockAsm8Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  BX, AX
+
+emit_literal_done_match_emit_encodeSnappyBetterBlockAsm8B:
+        ADDL R11, CX
+        ADDL $0x04, R11
+        MOVL CX, 12(SP)
+
+        // emitCopy
+two_byte_offset_match_nolit_encodeSnappyBetterBlockAsm8B:
+        CMPL R11, $0x40
+        JBE  two_byte_offset_short_match_nolit_encodeSnappyBetterBlockAsm8B
+        MOVB $0xee, (AX)
+        MOVW DI, 1(AX)
+        LEAL -60(R11), R11
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_match_nolit_encodeSnappyBetterBlockAsm8B
+
+two_byte_offset_short_match_nolit_encodeSnappyBetterBlockAsm8B:
+        MOVL R11, BX
+        SHLL $0x02, BX
+        CMPL R11, $0x0c
+        JAE  emit_copy_three_match_nolit_encodeSnappyBetterBlockAsm8B
+        LEAL -15(BX), BX
+        MOVB DI, 1(AX)
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, BX
+        MOVB BL, (AX)
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_encodeSnappyBetterBlockAsm8B
+
+emit_copy_three_match_nolit_encodeSnappyBetterBlockAsm8B:
+        LEAL -2(BX), BX
+        MOVB BL, (AX)
+        MOVW DI, 1(AX)
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_encodeSnappyBetterBlockAsm8B:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_encodeSnappyBetterBlockAsm8B
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_encodeSnappyBetterBlockAsm8B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+match_nolit_dst_ok_encodeSnappyBetterBlockAsm8B:
+        MOVQ  $0x0000cf1bbcdcbf9b, BX
+        MOVQ  $0x9e3779b1, DI
+        LEAQ  1(SI), SI
+        LEAQ  -2(CX), R8
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  1(DX)(SI*1), R10
+        MOVQ  (DX)(R8*1), R11
+        MOVQ  1(DX)(R8*1), R12
+        SHLQ  $0x10, R9
+        IMULQ BX, R9
+        SHRQ  $0x36, R9
+        SHLQ  $0x20, R10
+        IMULQ DI, R10
+        SHRQ  $0x38, R10
+        SHLQ  $0x10, R11
+        IMULQ BX, R11
+        SHRQ  $0x36, R11
+        SHLQ  $0x20, R12
+        IMULQ DI, R12
+        SHRQ  $0x38, R12
+        LEAQ  1(SI), DI
+        LEAQ  1(R8), R13
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  R8, 24(SP)(R11*4)
+        MOVL  DI, 4120(SP)(R10*4)
+        MOVL  R13, 4120(SP)(R12*4)
+        LEAQ  1(R8)(SI*1), DI
+        SHRQ  $0x01, DI
+        ADDQ  $0x01, SI
+        SUBQ  $0x01, R8
+
+index_loop_encodeSnappyBetterBlockAsm8B:
+        CMPQ  DI, R8
+        JAE   search_loop_encodeSnappyBetterBlockAsm8B
+        MOVQ  (DX)(SI*1), R9
+        MOVQ  (DX)(DI*1), R10
+        SHLQ  $0x10, R9
+        IMULQ BX, R9
+        SHRQ  $0x36, R9
+        SHLQ  $0x10, R10
+        IMULQ BX, R10
+        SHRQ  $0x36, R10
+        MOVL  SI, 24(SP)(R9*4)
+        MOVL  DI, 24(SP)(R10*4)
+        ADDQ  $0x02, SI
+        ADDQ  $0x02, DI
+        JMP   index_loop_encodeSnappyBetterBlockAsm8B
+
+emit_remainder_encodeSnappyBetterBlockAsm8B:
+        MOVQ src_len+32(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_encodeSnappyBetterBlockAsm8B
+        MOVQ $0x00000000, ret+48(FP)
+        RET
+
+emit_remainder_ok_encodeSnappyBetterBlockAsm8B:
+        MOVQ src_len+32(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm8B
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), DX
+        CMPL DX, $0x3c
+        JB   one_byte_emit_remainder_encodeSnappyBetterBlockAsm8B
+        CMPL DX, $0x00000100
+        JB   two_bytes_emit_remainder_encodeSnappyBetterBlockAsm8B
+        JB   three_bytes_emit_remainder_encodeSnappyBetterBlockAsm8B
+
+three_bytes_emit_remainder_encodeSnappyBetterBlockAsm8B:
+        MOVB $0xf4, (AX)
+        MOVW DX, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_encodeSnappyBetterBlockAsm8B
+
+two_bytes_emit_remainder_encodeSnappyBetterBlockAsm8B:
+        MOVB $0xf0, (AX)
+        MOVB DL, 1(AX)
+        ADDQ $0x02, AX
+        CMPL DX, $0x40
+        JB   memmove_emit_remainder_encodeSnappyBetterBlockAsm8B
+        JMP  memmove_long_emit_remainder_encodeSnappyBetterBlockAsm8B
+
+one_byte_emit_remainder_encodeSnappyBetterBlockAsm8B:
+        SHLB $0x02, DL
+        MOVB DL, (AX)
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_encodeSnappyBetterBlockAsm8B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveShort
+        CMPQ BX, $0x03
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm8B_memmove_move_1or2
+        JE   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm8B_memmove_move_3
+        CMPQ BX, $0x08
+        JB   emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm8B_memmove_move_4through7
+        CMPQ BX, $0x10
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm8B_memmove_move_8through16
+        CMPQ BX, $0x20
+        JBE  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm8B_memmove_move_17through32
+        JMP  emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm8B_memmove_move_33through64
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm8B_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(BX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm8B_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm8B_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(BX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm8B_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(BX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(BX*1)
+        JMP  memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm8B_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(BX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(BX*1)
+        JMP   memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm8B
+
+emit_lit_memmove_emit_remainder_encodeSnappyBetterBlockAsm8B_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+
+memmove_end_copy_emit_remainder_encodeSnappyBetterBlockAsm8B:
+        MOVQ DX, AX
+        JMP  emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm8B
+
+memmove_long_emit_remainder_encodeSnappyBetterBlockAsm8B:
+        LEAQ (AX)(SI*1), DX
+        MOVL SI, BX
+
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(BX*1), X2
+        MOVOU -16(CX)(BX*1), X3
+        MOVQ  BX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm8Blarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm8Blarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm8Blarge_big_loop_back
+
+emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm8Blarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  BX, R8
+        JAE   emit_lit_memmove_long_emit_remainder_encodeSnappyBetterBlockAsm8Blarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(BX*1)
+        MOVOU X3, -16(AX)(BX*1)
+        MOVQ  DX, AX
+
+emit_literal_done_emit_remainder_encodeSnappyBetterBlockAsm8B:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ AX, ret+48(FP)
+        RET
+
+// func calcBlockSize(src []byte) int
+// Requires: BMI, SSE2
+TEXT ·calcBlockSize(SB), $32792-32
+        XORQ AX, AX
+        MOVQ $0x00000100, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_calcBlockSize:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_calcBlockSize
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+8(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  CX, 16(SP)
+        MOVQ  src_base+0(FP), DX
+
+search_loop_calcBlockSize:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x05, BX
+        LEAL  4(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_calcBlockSize
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHRQ  $0x08, R10
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x33, R9
+        SHLQ  $0x10, R10
+        IMULQ R8, R10
+        SHRQ  $0x33, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  24(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        LEAL  1(CX), R9
+        MOVL  R9, 24(SP)(R10*4)
+        MOVQ  SI, R9
+        SHRQ  $0x10, R9
+        SHLQ  $0x10, R9
+        IMULQ R8, R9
+        SHRQ  $0x33, R9
+        MOVL  CX, R8
+        SUBL  16(SP), R8
+        MOVL  1(DX)(R8*1), R10
+        MOVQ  SI, R8
+        SHRQ  $0x08, R8
+        CMPL  R8, R10
+        JNE   no_repeat_found_calcBlockSize
+        LEAL  1(CX), SI
+        MOVL  12(SP), BX
+        MOVL  SI, DI
+        SUBL  16(SP), DI
+        JZ    repeat_extend_back_end_calcBlockSize
+
+repeat_extend_back_loop_calcBlockSize:
+        CMPL SI, BX
+        JBE  repeat_extend_back_end_calcBlockSize
+        MOVB -1(DX)(DI*1), R8
+        MOVB -1(DX)(SI*1), R9
+        CMPB R8, R9
+        JNE  repeat_extend_back_end_calcBlockSize
+        LEAL -1(SI), SI
+        DECL DI
+        JNZ  repeat_extend_back_loop_calcBlockSize
+
+repeat_extend_back_end_calcBlockSize:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_repeat_emit_calcBlockSize
+        MOVL SI, DI
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R8
+        SUBL BX, DI
+        LEAL -1(DI), BX
+        CMPL BX, $0x3c
+        JB   one_byte_repeat_emit_calcBlockSize
+        CMPL BX, $0x00000100
+        JB   two_bytes_repeat_emit_calcBlockSize
+        CMPL BX, $0x00010000
+        JB   three_bytes_repeat_emit_calcBlockSize
+        CMPL BX, $0x01000000
+        JB   four_bytes_repeat_emit_calcBlockSize
+        ADDQ $0x05, AX
+        JMP  memmove_long_repeat_emit_calcBlockSize
+
+four_bytes_repeat_emit_calcBlockSize:
+        ADDQ $0x04, AX
+        JMP  memmove_long_repeat_emit_calcBlockSize
+
+three_bytes_repeat_emit_calcBlockSize:
+        ADDQ $0x03, AX
+        JMP  memmove_long_repeat_emit_calcBlockSize
+
+two_bytes_repeat_emit_calcBlockSize:
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_repeat_emit_calcBlockSize
+        JMP  memmove_long_repeat_emit_calcBlockSize
+
+one_byte_repeat_emit_calcBlockSize:
+        ADDQ $0x01, AX
+
+memmove_repeat_emit_calcBlockSize:
+        LEAQ (AX)(DI*1), AX
+        JMP  emit_literal_done_repeat_emit_calcBlockSize
+
+memmove_long_repeat_emit_calcBlockSize:
+        LEAQ (AX)(DI*1), AX
+
+emit_literal_done_repeat_emit_calcBlockSize:
+        ADDL $0x05, CX
+        MOVL CX, BX
+        SUBL 16(SP), BX
+        MOVQ src_len+8(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R10, R10
+
+matchlen_loopback_16_repeat_extend_calcBlockSize:
+        CMPL DI, $0x10
+        JB   matchlen_match8_repeat_extend_calcBlockSize
+        MOVQ (R8)(R10*1), R9
+        MOVQ 8(R8)(R10*1), R11
+        XORQ (BX)(R10*1), R9
+        JNZ  matchlen_bsf_8_repeat_extend_calcBlockSize
+        XORQ 8(BX)(R10*1), R11
+        JNZ  matchlen_bsf_16repeat_extend_calcBlockSize
+        LEAL -16(DI), DI
+        LEAL 16(R10), R10
+        JMP  matchlen_loopback_16_repeat_extend_calcBlockSize
+
+matchlen_bsf_16repeat_extend_calcBlockSize:
+#ifdef GOAMD64_v3
+        TZCNTQ R11, R11
+
+#else
+        BSFQ R11, R11
+
+#endif
+        SARQ $0x03, R11
+        LEAL 8(R10)(R11*1), R10
+        JMP  repeat_extend_forward_end_calcBlockSize
+
+matchlen_match8_repeat_extend_calcBlockSize:
+        CMPL DI, $0x08
+        JB   matchlen_match4_repeat_extend_calcBlockSize
+        MOVQ (R8)(R10*1), R9
+        XORQ (BX)(R10*1), R9
+        JNZ  matchlen_bsf_8_repeat_extend_calcBlockSize
+        LEAL -8(DI), DI
+        LEAL 8(R10), R10
+        JMP  matchlen_match4_repeat_extend_calcBlockSize
+
+matchlen_bsf_8_repeat_extend_calcBlockSize:
+#ifdef GOAMD64_v3
+        TZCNTQ R9, R9
+
+#else
+        BSFQ R9, R9
+
+#endif
+        SARQ $0x03, R9
+        LEAL (R10)(R9*1), R10
+        JMP  repeat_extend_forward_end_calcBlockSize
+
+matchlen_match4_repeat_extend_calcBlockSize:
+        CMPL DI, $0x04
+        JB   matchlen_match2_repeat_extend_calcBlockSize
+        MOVL (R8)(R10*1), R9
+        CMPL (BX)(R10*1), R9
+        JNE  matchlen_match2_repeat_extend_calcBlockSize
+        LEAL -4(DI), DI
+        LEAL 4(R10), R10
+
+matchlen_match2_repeat_extend_calcBlockSize:
+        CMPL DI, $0x01
+        JE   matchlen_match1_repeat_extend_calcBlockSize
+        JB   repeat_extend_forward_end_calcBlockSize
+        MOVW (R8)(R10*1), R9
+        CMPW (BX)(R10*1), R9
+        JNE  matchlen_match1_repeat_extend_calcBlockSize
+        LEAL 2(R10), R10
+        SUBL $0x02, DI
+        JZ   repeat_extend_forward_end_calcBlockSize
+
+matchlen_match1_repeat_extend_calcBlockSize:
+        MOVB (R8)(R10*1), R9
+        CMPB (BX)(R10*1), R9
+        JNE  repeat_extend_forward_end_calcBlockSize
+        LEAL 1(R10), R10
+
+repeat_extend_forward_end_calcBlockSize:
+        ADDL R10, CX
+        MOVL CX, BX
+        SUBL SI, BX
+        MOVL 16(SP), SI
+
+        // emitCopy
+        CMPL SI, $0x00010000
+        JB   two_byte_offset_repeat_as_copy_calcBlockSize
+
+four_bytes_loop_back_repeat_as_copy_calcBlockSize:
+        CMPL BX, $0x40
+        JBE  four_bytes_remain_repeat_as_copy_calcBlockSize
+        LEAL -64(BX), BX
+        ADDQ $0x05, AX
+        CMPL BX, $0x04
+        JB   four_bytes_remain_repeat_as_copy_calcBlockSize
+        JMP  four_bytes_loop_back_repeat_as_copy_calcBlockSize
+
+four_bytes_remain_repeat_as_copy_calcBlockSize:
+        TESTL BX, BX
+        JZ    repeat_end_emit_calcBlockSize
+        XORL  BX, BX
+        ADDQ  $0x05, AX
+        JMP   repeat_end_emit_calcBlockSize
+
+two_byte_offset_repeat_as_copy_calcBlockSize:
+        CMPL BX, $0x40
+        JBE  two_byte_offset_short_repeat_as_copy_calcBlockSize
+        LEAL -60(BX), BX
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_repeat_as_copy_calcBlockSize
+
+two_byte_offset_short_repeat_as_copy_calcBlockSize:
+        MOVL BX, DI
+        SHLL $0x02, DI
+        CMPL BX, $0x0c
+        JAE  emit_copy_three_repeat_as_copy_calcBlockSize
+        CMPL SI, $0x00000800
+        JAE  emit_copy_three_repeat_as_copy_calcBlockSize
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_calcBlockSize
+
+emit_copy_three_repeat_as_copy_calcBlockSize:
+        ADDQ $0x03, AX
+
+repeat_end_emit_calcBlockSize:
+        MOVL CX, 12(SP)
+        JMP  search_loop_calcBlockSize
+
+no_repeat_found_calcBlockSize:
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate_match_calcBlockSize
+        SHRQ $0x08, SI
+        MOVL 24(SP)(R9*4), BX
+        LEAL 2(CX), R8
+        CMPL (DX)(DI*1), SI
+        JEQ  candidate2_match_calcBlockSize
+        MOVL R8, 24(SP)(R9*4)
+        SHRQ $0x08, SI
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate3_match_calcBlockSize
+        MOVL 20(SP), CX
+        JMP  search_loop_calcBlockSize
+
+candidate3_match_calcBlockSize:
+        ADDL $0x02, CX
+        JMP  candidate_match_calcBlockSize
+
+candidate2_match_calcBlockSize:
+        MOVL R8, 24(SP)(R9*4)
+        INCL CX
+        MOVL DI, BX
+
+candidate_match_calcBlockSize:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_calcBlockSize
+
+match_extend_back_loop_calcBlockSize:
+        CMPL CX, SI
+        JBE  match_extend_back_end_calcBlockSize
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_calcBlockSize
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_calcBlockSize
+        JMP  match_extend_back_loop_calcBlockSize
+
+match_extend_back_end_calcBlockSize:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 5(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_calcBlockSize
+        MOVQ $0x00000000, ret+24(FP)
+        RET
+
+match_dst_size_check_calcBlockSize:
+        MOVL CX, SI
+        MOVL 12(SP), DI
+        CMPL DI, SI
+        JEQ  emit_literal_done_match_emit_calcBlockSize
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(DI*1), SI
+        SUBL DI, R8
+        LEAL -1(R8), SI
+        CMPL SI, $0x3c
+        JB   one_byte_match_emit_calcBlockSize
+        CMPL SI, $0x00000100
+        JB   two_bytes_match_emit_calcBlockSize
+        CMPL SI, $0x00010000
+        JB   three_bytes_match_emit_calcBlockSize
+        CMPL SI, $0x01000000
+        JB   four_bytes_match_emit_calcBlockSize
+        ADDQ $0x05, AX
+        JMP  memmove_long_match_emit_calcBlockSize
+
+four_bytes_match_emit_calcBlockSize:
+        ADDQ $0x04, AX
+        JMP  memmove_long_match_emit_calcBlockSize
+
+three_bytes_match_emit_calcBlockSize:
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_calcBlockSize
+
+two_bytes_match_emit_calcBlockSize:
+        ADDQ $0x02, AX
+        CMPL SI, $0x40
+        JB   memmove_match_emit_calcBlockSize
+        JMP  memmove_long_match_emit_calcBlockSize
+
+one_byte_match_emit_calcBlockSize:
+        ADDQ $0x01, AX
+
+memmove_match_emit_calcBlockSize:
+        LEAQ (AX)(R8*1), AX
+        JMP  emit_literal_done_match_emit_calcBlockSize
+
+memmove_long_match_emit_calcBlockSize:
+        LEAQ (AX)(R8*1), AX
+
+emit_literal_done_match_emit_calcBlockSize:
+match_nolit_loop_calcBlockSize:
+        MOVL CX, SI
+        SUBL BX, SI
+        MOVL SI, 16(SP)
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+8(FP), SI
+        SUBL CX, SI
+        LEAQ (DX)(CX*1), DI
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R9, R9
+
+matchlen_loopback_16_match_nolit_calcBlockSize:
+        CMPL SI, $0x10
+        JB   matchlen_match8_match_nolit_calcBlockSize
+        MOVQ (DI)(R9*1), R8
+        MOVQ 8(DI)(R9*1), R10
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_calcBlockSize
+        XORQ 8(BX)(R9*1), R10
+        JNZ  matchlen_bsf_16match_nolit_calcBlockSize
+        LEAL -16(SI), SI
+        LEAL 16(R9), R9
+        JMP  matchlen_loopback_16_match_nolit_calcBlockSize
+
+matchlen_bsf_16match_nolit_calcBlockSize:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL 8(R9)(R10*1), R9
+        JMP  match_nolit_end_calcBlockSize
+
+matchlen_match8_match_nolit_calcBlockSize:
+        CMPL SI, $0x08
+        JB   matchlen_match4_match_nolit_calcBlockSize
+        MOVQ (DI)(R9*1), R8
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_calcBlockSize
+        LEAL -8(SI), SI
+        LEAL 8(R9), R9
+        JMP  matchlen_match4_match_nolit_calcBlockSize
+
+matchlen_bsf_8_match_nolit_calcBlockSize:
+#ifdef GOAMD64_v3
+        TZCNTQ R8, R8
+
+#else
+        BSFQ R8, R8
+
+#endif
+        SARQ $0x03, R8
+        LEAL (R9)(R8*1), R9
+        JMP  match_nolit_end_calcBlockSize
+
+matchlen_match4_match_nolit_calcBlockSize:
+        CMPL SI, $0x04
+        JB   matchlen_match2_match_nolit_calcBlockSize
+        MOVL (DI)(R9*1), R8
+        CMPL (BX)(R9*1), R8
+        JNE  matchlen_match2_match_nolit_calcBlockSize
+        LEAL -4(SI), SI
+        LEAL 4(R9), R9
+
+matchlen_match2_match_nolit_calcBlockSize:
+        CMPL SI, $0x01
+        JE   matchlen_match1_match_nolit_calcBlockSize
+        JB   match_nolit_end_calcBlockSize
+        MOVW (DI)(R9*1), R8
+        CMPW (BX)(R9*1), R8
+        JNE  matchlen_match1_match_nolit_calcBlockSize
+        LEAL 2(R9), R9
+        SUBL $0x02, SI
+        JZ   match_nolit_end_calcBlockSize
+
+matchlen_match1_match_nolit_calcBlockSize:
+        MOVB (DI)(R9*1), R8
+        CMPB (BX)(R9*1), R8
+        JNE  match_nolit_end_calcBlockSize
+        LEAL 1(R9), R9
+
+match_nolit_end_calcBlockSize:
+        ADDL R9, CX
+        MOVL 16(SP), BX
+        ADDL $0x04, R9
+        MOVL CX, 12(SP)
+
+        // emitCopy
+        CMPL BX, $0x00010000
+        JB   two_byte_offset_match_nolit_calcBlockSize
+
+four_bytes_loop_back_match_nolit_calcBlockSize:
+        CMPL R9, $0x40
+        JBE  four_bytes_remain_match_nolit_calcBlockSize
+        LEAL -64(R9), R9
+        ADDQ $0x05, AX
+        CMPL R9, $0x04
+        JB   four_bytes_remain_match_nolit_calcBlockSize
+        JMP  four_bytes_loop_back_match_nolit_calcBlockSize
+
+four_bytes_remain_match_nolit_calcBlockSize:
+        TESTL R9, R9
+        JZ    match_nolit_emitcopy_end_calcBlockSize
+        XORL  BX, BX
+        ADDQ  $0x05, AX
+        JMP   match_nolit_emitcopy_end_calcBlockSize
+
+two_byte_offset_match_nolit_calcBlockSize:
+        CMPL R9, $0x40
+        JBE  two_byte_offset_short_match_nolit_calcBlockSize
+        LEAL -60(R9), R9
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_match_nolit_calcBlockSize
+
+two_byte_offset_short_match_nolit_calcBlockSize:
+        MOVL R9, SI
+        SHLL $0x02, SI
+        CMPL R9, $0x0c
+        JAE  emit_copy_three_match_nolit_calcBlockSize
+        CMPL BX, $0x00000800
+        JAE  emit_copy_three_match_nolit_calcBlockSize
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_calcBlockSize
+
+emit_copy_three_match_nolit_calcBlockSize:
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_calcBlockSize:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_calcBlockSize
+        MOVQ -2(DX)(CX*1), SI
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_calcBlockSize
+        MOVQ $0x00000000, ret+24(FP)
+        RET
+
+match_nolit_dst_ok_calcBlockSize:
+        MOVQ  $0x0000cf1bbcdcbf9b, R8
+        MOVQ  SI, DI
+        SHRQ  $0x10, SI
+        MOVQ  SI, BX
+        SHLQ  $0x10, DI
+        IMULQ R8, DI
+        SHRQ  $0x33, DI
+        SHLQ  $0x10, BX
+        IMULQ R8, BX
+        SHRQ  $0x33, BX
+        LEAL  -2(CX), R8
+        LEAQ  24(SP)(BX*4), R9
+        MOVL  (R9), BX
+        MOVL  R8, 24(SP)(DI*4)
+        MOVL  CX, (R9)
+        CMPL  (DX)(BX*1), SI
+        JEQ   match_nolit_loop_calcBlockSize
+        INCL  CX
+        JMP   search_loop_calcBlockSize
+
+emit_remainder_calcBlockSize:
+        MOVQ src_len+8(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 5(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_calcBlockSize
+        MOVQ $0x00000000, ret+24(FP)
+        RET
+
+emit_remainder_ok_calcBlockSize:
+        MOVQ src_len+8(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_calcBlockSize
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), CX
+        CMPL CX, $0x3c
+        JB   one_byte_emit_remainder_calcBlockSize
+        CMPL CX, $0x00000100
+        JB   two_bytes_emit_remainder_calcBlockSize
+        CMPL CX, $0x00010000
+        JB   three_bytes_emit_remainder_calcBlockSize
+        CMPL CX, $0x01000000
+        JB   four_bytes_emit_remainder_calcBlockSize
+        ADDQ $0x05, AX
+        JMP  memmove_long_emit_remainder_calcBlockSize
+
+four_bytes_emit_remainder_calcBlockSize:
+        ADDQ $0x04, AX
+        JMP  memmove_long_emit_remainder_calcBlockSize
+
+three_bytes_emit_remainder_calcBlockSize:
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_calcBlockSize
+
+two_bytes_emit_remainder_calcBlockSize:
+        ADDQ $0x02, AX
+        CMPL CX, $0x40
+        JB   memmove_emit_remainder_calcBlockSize
+        JMP  memmove_long_emit_remainder_calcBlockSize
+
+one_byte_emit_remainder_calcBlockSize:
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_calcBlockSize:
+        LEAQ (AX)(SI*1), AX
+        JMP  emit_literal_done_emit_remainder_calcBlockSize
+
+memmove_long_emit_remainder_calcBlockSize:
+        LEAQ (AX)(SI*1), AX
+
+emit_literal_done_emit_remainder_calcBlockSize:
+        MOVQ AX, ret+24(FP)
+        RET
+
+// func calcBlockSizeSmall(src []byte) int
+// Requires: BMI, SSE2
+TEXT ·calcBlockSizeSmall(SB), $2072-32
+        XORQ AX, AX
+        MOVQ $0x00000010, CX
+        LEAQ 24(SP), DX
+        PXOR X0, X0
+
+zero_loop_calcBlockSizeSmall:
+        MOVOU X0, (DX)
+        MOVOU X0, 16(DX)
+        MOVOU X0, 32(DX)
+        MOVOU X0, 48(DX)
+        MOVOU X0, 64(DX)
+        MOVOU X0, 80(DX)
+        MOVOU X0, 96(DX)
+        MOVOU X0, 112(DX)
+        ADDQ  $0x80, DX
+        DECQ  CX
+        JNZ   zero_loop_calcBlockSizeSmall
+        MOVL  $0x00000000, 12(SP)
+        MOVQ  src_len+8(FP), CX
+        LEAQ  -9(CX), DX
+        LEAQ  -8(CX), BX
+        MOVL  BX, 8(SP)
+        SHRQ  $0x05, CX
+        SUBL  CX, DX
+        LEAQ  (AX)(DX*1), DX
+        MOVQ  DX, (SP)
+        MOVL  $0x00000001, CX
+        MOVL  CX, 16(SP)
+        MOVQ  src_base+0(FP), DX
+
+search_loop_calcBlockSizeSmall:
+        MOVL  CX, BX
+        SUBL  12(SP), BX
+        SHRL  $0x04, BX
+        LEAL  4(CX)(BX*1), BX
+        CMPL  BX, 8(SP)
+        JAE   emit_remainder_calcBlockSizeSmall
+        MOVQ  (DX)(CX*1), SI
+        MOVL  BX, 20(SP)
+        MOVQ  $0x9e3779b1, R8
+        MOVQ  SI, R9
+        MOVQ  SI, R10
+        SHRQ  $0x08, R10
+        SHLQ  $0x20, R9
+        IMULQ R8, R9
+        SHRQ  $0x37, R9
+        SHLQ  $0x20, R10
+        IMULQ R8, R10
+        SHRQ  $0x37, R10
+        MOVL  24(SP)(R9*4), BX
+        MOVL  24(SP)(R10*4), DI
+        MOVL  CX, 24(SP)(R9*4)
+        LEAL  1(CX), R9
+        MOVL  R9, 24(SP)(R10*4)
+        MOVQ  SI, R9
+        SHRQ  $0x10, R9
+        SHLQ  $0x20, R9
+        IMULQ R8, R9
+        SHRQ  $0x37, R9
+        MOVL  CX, R8
+        SUBL  16(SP), R8
+        MOVL  1(DX)(R8*1), R10
+        MOVQ  SI, R8
+        SHRQ  $0x08, R8
+        CMPL  R8, R10
+        JNE   no_repeat_found_calcBlockSizeSmall
+        LEAL  1(CX), SI
+        MOVL  12(SP), BX
+        MOVL  SI, DI
+        SUBL  16(SP), DI
+        JZ    repeat_extend_back_end_calcBlockSizeSmall
+
+repeat_extend_back_loop_calcBlockSizeSmall:
+        CMPL SI, BX
+        JBE  repeat_extend_back_end_calcBlockSizeSmall
+        MOVB -1(DX)(DI*1), R8
+        MOVB -1(DX)(SI*1), R9
+        CMPB R8, R9
+        JNE  repeat_extend_back_end_calcBlockSizeSmall
+        LEAL -1(SI), SI
+        DECL DI
+        JNZ  repeat_extend_back_loop_calcBlockSizeSmall
+
+repeat_extend_back_end_calcBlockSizeSmall:
+        MOVL 12(SP), BX
+        CMPL BX, SI
+        JEQ  emit_literal_done_repeat_emit_calcBlockSizeSmall
+        MOVL SI, DI
+        MOVL SI, 12(SP)
+        LEAQ (DX)(BX*1), R8
+        SUBL BX, DI
+        LEAL -1(DI), BX
+        CMPL BX, $0x3c
+        JB   one_byte_repeat_emit_calcBlockSizeSmall
+        CMPL BX, $0x00000100
+        JB   two_bytes_repeat_emit_calcBlockSizeSmall
+        JB   three_bytes_repeat_emit_calcBlockSizeSmall
+
+three_bytes_repeat_emit_calcBlockSizeSmall:
+        ADDQ $0x03, AX
+        JMP  memmove_long_repeat_emit_calcBlockSizeSmall
+
+two_bytes_repeat_emit_calcBlockSizeSmall:
+        ADDQ $0x02, AX
+        CMPL BX, $0x40
+        JB   memmove_repeat_emit_calcBlockSizeSmall
+        JMP  memmove_long_repeat_emit_calcBlockSizeSmall
+
+one_byte_repeat_emit_calcBlockSizeSmall:
+        ADDQ $0x01, AX
+
+memmove_repeat_emit_calcBlockSizeSmall:
+        LEAQ (AX)(DI*1), AX
+        JMP  emit_literal_done_repeat_emit_calcBlockSizeSmall
+
+memmove_long_repeat_emit_calcBlockSizeSmall:
+        LEAQ (AX)(DI*1), AX
+
+emit_literal_done_repeat_emit_calcBlockSizeSmall:
+        ADDL $0x05, CX
+        MOVL CX, BX
+        SUBL 16(SP), BX
+        MOVQ src_len+8(FP), DI
+        SUBL CX, DI
+        LEAQ (DX)(CX*1), R8
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R10, R10
+
+matchlen_loopback_16_repeat_extend_calcBlockSizeSmall:
+        CMPL DI, $0x10
+        JB   matchlen_match8_repeat_extend_calcBlockSizeSmall
+        MOVQ (R8)(R10*1), R9
+        MOVQ 8(R8)(R10*1), R11
+        XORQ (BX)(R10*1), R9
+        JNZ  matchlen_bsf_8_repeat_extend_calcBlockSizeSmall
+        XORQ 8(BX)(R10*1), R11
+        JNZ  matchlen_bsf_16repeat_extend_calcBlockSizeSmall
+        LEAL -16(DI), DI
+        LEAL 16(R10), R10
+        JMP  matchlen_loopback_16_repeat_extend_calcBlockSizeSmall
+
+matchlen_bsf_16repeat_extend_calcBlockSizeSmall:
+#ifdef GOAMD64_v3
+        TZCNTQ R11, R11
+
+#else
+        BSFQ R11, R11
+
+#endif
+        SARQ $0x03, R11
+        LEAL 8(R10)(R11*1), R10
+        JMP  repeat_extend_forward_end_calcBlockSizeSmall
+
+matchlen_match8_repeat_extend_calcBlockSizeSmall:
+        CMPL DI, $0x08
+        JB   matchlen_match4_repeat_extend_calcBlockSizeSmall
+        MOVQ (R8)(R10*1), R9
+        XORQ (BX)(R10*1), R9
+        JNZ  matchlen_bsf_8_repeat_extend_calcBlockSizeSmall
+        LEAL -8(DI), DI
+        LEAL 8(R10), R10
+        JMP  matchlen_match4_repeat_extend_calcBlockSizeSmall
+
+matchlen_bsf_8_repeat_extend_calcBlockSizeSmall:
+#ifdef GOAMD64_v3
+        TZCNTQ R9, R9
+
+#else
+        BSFQ R9, R9
+
+#endif
+        SARQ $0x03, R9
+        LEAL (R10)(R9*1), R10
+        JMP  repeat_extend_forward_end_calcBlockSizeSmall
+
+matchlen_match4_repeat_extend_calcBlockSizeSmall:
+        CMPL DI, $0x04
+        JB   matchlen_match2_repeat_extend_calcBlockSizeSmall
+        MOVL (R8)(R10*1), R9
+        CMPL (BX)(R10*1), R9
+        JNE  matchlen_match2_repeat_extend_calcBlockSizeSmall
+        LEAL -4(DI), DI
+        LEAL 4(R10), R10
+
+matchlen_match2_repeat_extend_calcBlockSizeSmall:
+        CMPL DI, $0x01
+        JE   matchlen_match1_repeat_extend_calcBlockSizeSmall
+        JB   repeat_extend_forward_end_calcBlockSizeSmall
+        MOVW (R8)(R10*1), R9
+        CMPW (BX)(R10*1), R9
+        JNE  matchlen_match1_repeat_extend_calcBlockSizeSmall
+        LEAL 2(R10), R10
+        SUBL $0x02, DI
+        JZ   repeat_extend_forward_end_calcBlockSizeSmall
+
+matchlen_match1_repeat_extend_calcBlockSizeSmall:
+        MOVB (R8)(R10*1), R9
+        CMPB (BX)(R10*1), R9
+        JNE  repeat_extend_forward_end_calcBlockSizeSmall
+        LEAL 1(R10), R10
+
+repeat_extend_forward_end_calcBlockSizeSmall:
+        ADDL R10, CX
+        MOVL CX, BX
+        SUBL SI, BX
+        MOVL 16(SP), SI
+
+        // emitCopy
+two_byte_offset_repeat_as_copy_calcBlockSizeSmall:
+        CMPL BX, $0x40
+        JBE  two_byte_offset_short_repeat_as_copy_calcBlockSizeSmall
+        LEAL -60(BX), BX
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_repeat_as_copy_calcBlockSizeSmall
+
+two_byte_offset_short_repeat_as_copy_calcBlockSizeSmall:
+        MOVL BX, SI
+        SHLL $0x02, SI
+        CMPL BX, $0x0c
+        JAE  emit_copy_three_repeat_as_copy_calcBlockSizeSmall
+        ADDQ $0x02, AX
+        JMP  repeat_end_emit_calcBlockSizeSmall
+
+emit_copy_three_repeat_as_copy_calcBlockSizeSmall:
+        ADDQ $0x03, AX
+
+repeat_end_emit_calcBlockSizeSmall:
+        MOVL CX, 12(SP)
+        JMP  search_loop_calcBlockSizeSmall
+
+no_repeat_found_calcBlockSizeSmall:
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate_match_calcBlockSizeSmall
+        SHRQ $0x08, SI
+        MOVL 24(SP)(R9*4), BX
+        LEAL 2(CX), R8
+        CMPL (DX)(DI*1), SI
+        JEQ  candidate2_match_calcBlockSizeSmall
+        MOVL R8, 24(SP)(R9*4)
+        SHRQ $0x08, SI
+        CMPL (DX)(BX*1), SI
+        JEQ  candidate3_match_calcBlockSizeSmall
+        MOVL 20(SP), CX
+        JMP  search_loop_calcBlockSizeSmall
+
+candidate3_match_calcBlockSizeSmall:
+        ADDL $0x02, CX
+        JMP  candidate_match_calcBlockSizeSmall
+
+candidate2_match_calcBlockSizeSmall:
+        MOVL R8, 24(SP)(R9*4)
+        INCL CX
+        MOVL DI, BX
+
+candidate_match_calcBlockSizeSmall:
+        MOVL  12(SP), SI
+        TESTL BX, BX
+        JZ    match_extend_back_end_calcBlockSizeSmall
+
+match_extend_back_loop_calcBlockSizeSmall:
+        CMPL CX, SI
+        JBE  match_extend_back_end_calcBlockSizeSmall
+        MOVB -1(DX)(BX*1), DI
+        MOVB -1(DX)(CX*1), R8
+        CMPB DI, R8
+        JNE  match_extend_back_end_calcBlockSizeSmall
+        LEAL -1(CX), CX
+        DECL BX
+        JZ   match_extend_back_end_calcBlockSizeSmall
+        JMP  match_extend_back_loop_calcBlockSizeSmall
+
+match_extend_back_end_calcBlockSizeSmall:
+        MOVL CX, SI
+        SUBL 12(SP), SI
+        LEAQ 3(AX)(SI*1), SI
+        CMPQ SI, (SP)
+        JB   match_dst_size_check_calcBlockSizeSmall
+        MOVQ $0x00000000, ret+24(FP)
+        RET
+
+match_dst_size_check_calcBlockSizeSmall:
+        MOVL CX, SI
+        MOVL 12(SP), DI
+        CMPL DI, SI
+        JEQ  emit_literal_done_match_emit_calcBlockSizeSmall
+        MOVL SI, R8
+        MOVL SI, 12(SP)
+        LEAQ (DX)(DI*1), SI
+        SUBL DI, R8
+        LEAL -1(R8), SI
+        CMPL SI, $0x3c
+        JB   one_byte_match_emit_calcBlockSizeSmall
+        CMPL SI, $0x00000100
+        JB   two_bytes_match_emit_calcBlockSizeSmall
+        JB   three_bytes_match_emit_calcBlockSizeSmall
+
+three_bytes_match_emit_calcBlockSizeSmall:
+        ADDQ $0x03, AX
+        JMP  memmove_long_match_emit_calcBlockSizeSmall
+
+two_bytes_match_emit_calcBlockSizeSmall:
+        ADDQ $0x02, AX
+        CMPL SI, $0x40
+        JB   memmove_match_emit_calcBlockSizeSmall
+        JMP  memmove_long_match_emit_calcBlockSizeSmall
+
+one_byte_match_emit_calcBlockSizeSmall:
+        ADDQ $0x01, AX
+
+memmove_match_emit_calcBlockSizeSmall:
+        LEAQ (AX)(R8*1), AX
+        JMP  emit_literal_done_match_emit_calcBlockSizeSmall
+
+memmove_long_match_emit_calcBlockSizeSmall:
+        LEAQ (AX)(R8*1), AX
+
+emit_literal_done_match_emit_calcBlockSizeSmall:
+match_nolit_loop_calcBlockSizeSmall:
+        MOVL CX, SI
+        SUBL BX, SI
+        MOVL SI, 16(SP)
+        ADDL $0x04, CX
+        ADDL $0x04, BX
+        MOVQ src_len+8(FP), SI
+        SUBL CX, SI
+        LEAQ (DX)(CX*1), DI
+        LEAQ (DX)(BX*1), BX
+
+        // matchLen
+        XORL R9, R9
+
+matchlen_loopback_16_match_nolit_calcBlockSizeSmall:
+        CMPL SI, $0x10
+        JB   matchlen_match8_match_nolit_calcBlockSizeSmall
+        MOVQ (DI)(R9*1), R8
+        MOVQ 8(DI)(R9*1), R10
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_calcBlockSizeSmall
+        XORQ 8(BX)(R9*1), R10
+        JNZ  matchlen_bsf_16match_nolit_calcBlockSizeSmall
+        LEAL -16(SI), SI
+        LEAL 16(R9), R9
+        JMP  matchlen_loopback_16_match_nolit_calcBlockSizeSmall
+
+matchlen_bsf_16match_nolit_calcBlockSizeSmall:
+#ifdef GOAMD64_v3
+        TZCNTQ R10, R10
+
+#else
+        BSFQ R10, R10
+
+#endif
+        SARQ $0x03, R10
+        LEAL 8(R9)(R10*1), R9
+        JMP  match_nolit_end_calcBlockSizeSmall
+
+matchlen_match8_match_nolit_calcBlockSizeSmall:
+        CMPL SI, $0x08
+        JB   matchlen_match4_match_nolit_calcBlockSizeSmall
+        MOVQ (DI)(R9*1), R8
+        XORQ (BX)(R9*1), R8
+        JNZ  matchlen_bsf_8_match_nolit_calcBlockSizeSmall
+        LEAL -8(SI), SI
+        LEAL 8(R9), R9
+        JMP  matchlen_match4_match_nolit_calcBlockSizeSmall
+
+matchlen_bsf_8_match_nolit_calcBlockSizeSmall:
+#ifdef GOAMD64_v3
+        TZCNTQ R8, R8
+
+#else
+        BSFQ R8, R8
+
+#endif
+        SARQ $0x03, R8
+        LEAL (R9)(R8*1), R9
+        JMP  match_nolit_end_calcBlockSizeSmall
+
+matchlen_match4_match_nolit_calcBlockSizeSmall:
+        CMPL SI, $0x04
+        JB   matchlen_match2_match_nolit_calcBlockSizeSmall
+        MOVL (DI)(R9*1), R8
+        CMPL (BX)(R9*1), R8
+        JNE  matchlen_match2_match_nolit_calcBlockSizeSmall
+        LEAL -4(SI), SI
+        LEAL 4(R9), R9
+
+matchlen_match2_match_nolit_calcBlockSizeSmall:
+        CMPL SI, $0x01
+        JE   matchlen_match1_match_nolit_calcBlockSizeSmall
+        JB   match_nolit_end_calcBlockSizeSmall
+        MOVW (DI)(R9*1), R8
+        CMPW (BX)(R9*1), R8
+        JNE  matchlen_match1_match_nolit_calcBlockSizeSmall
+        LEAL 2(R9), R9
+        SUBL $0x02, SI
+        JZ   match_nolit_end_calcBlockSizeSmall
+
+matchlen_match1_match_nolit_calcBlockSizeSmall:
+        MOVB (DI)(R9*1), R8
+        CMPB (BX)(R9*1), R8
+        JNE  match_nolit_end_calcBlockSizeSmall
+        LEAL 1(R9), R9
+
+match_nolit_end_calcBlockSizeSmall:
+        ADDL R9, CX
+        MOVL 16(SP), BX
+        ADDL $0x04, R9
+        MOVL CX, 12(SP)
+
+        // emitCopy
+two_byte_offset_match_nolit_calcBlockSizeSmall:
+        CMPL R9, $0x40
+        JBE  two_byte_offset_short_match_nolit_calcBlockSizeSmall
+        LEAL -60(R9), R9
+        ADDQ $0x03, AX
+        JMP  two_byte_offset_match_nolit_calcBlockSizeSmall
+
+two_byte_offset_short_match_nolit_calcBlockSizeSmall:
+        MOVL R9, BX
+        SHLL $0x02, BX
+        CMPL R9, $0x0c
+        JAE  emit_copy_three_match_nolit_calcBlockSizeSmall
+        ADDQ $0x02, AX
+        JMP  match_nolit_emitcopy_end_calcBlockSizeSmall
+
+emit_copy_three_match_nolit_calcBlockSizeSmall:
+        ADDQ $0x03, AX
+
+match_nolit_emitcopy_end_calcBlockSizeSmall:
+        CMPL CX, 8(SP)
+        JAE  emit_remainder_calcBlockSizeSmall
+        MOVQ -2(DX)(CX*1), SI
+        CMPQ AX, (SP)
+        JB   match_nolit_dst_ok_calcBlockSizeSmall
+        MOVQ $0x00000000, ret+24(FP)
+        RET
+
+match_nolit_dst_ok_calcBlockSizeSmall:
+        MOVQ  $0x9e3779b1, R8
+        MOVQ  SI, DI
+        SHRQ  $0x10, SI
+        MOVQ  SI, BX
+        SHLQ  $0x20, DI
+        IMULQ R8, DI
+        SHRQ  $0x37, DI
+        SHLQ  $0x20, BX
+        IMULQ R8, BX
+        SHRQ  $0x37, BX
+        LEAL  -2(CX), R8
+        LEAQ  24(SP)(BX*4), R9
+        MOVL  (R9), BX
+        MOVL  R8, 24(SP)(DI*4)
+        MOVL  CX, (R9)
+        CMPL  (DX)(BX*1), SI
+        JEQ   match_nolit_loop_calcBlockSizeSmall
+        INCL  CX
+        JMP   search_loop_calcBlockSizeSmall
+
+emit_remainder_calcBlockSizeSmall:
+        MOVQ src_len+8(FP), CX
+        SUBL 12(SP), CX
+        LEAQ 3(AX)(CX*1), CX
+        CMPQ CX, (SP)
+        JB   emit_remainder_ok_calcBlockSizeSmall
+        MOVQ $0x00000000, ret+24(FP)
+        RET
+
+emit_remainder_ok_calcBlockSizeSmall:
+        MOVQ src_len+8(FP), CX
+        MOVL 12(SP), BX
+        CMPL BX, CX
+        JEQ  emit_literal_done_emit_remainder_calcBlockSizeSmall
+        MOVL CX, SI
+        MOVL CX, 12(SP)
+        LEAQ (DX)(BX*1), CX
+        SUBL BX, SI
+        LEAL -1(SI), CX
+        CMPL CX, $0x3c
+        JB   one_byte_emit_remainder_calcBlockSizeSmall
+        CMPL CX, $0x00000100
+        JB   two_bytes_emit_remainder_calcBlockSizeSmall
+        JB   three_bytes_emit_remainder_calcBlockSizeSmall
+
+three_bytes_emit_remainder_calcBlockSizeSmall:
+        ADDQ $0x03, AX
+        JMP  memmove_long_emit_remainder_calcBlockSizeSmall
+
+two_bytes_emit_remainder_calcBlockSizeSmall:
+        ADDQ $0x02, AX
+        CMPL CX, $0x40
+        JB   memmove_emit_remainder_calcBlockSizeSmall
+        JMP  memmove_long_emit_remainder_calcBlockSizeSmall
+
+one_byte_emit_remainder_calcBlockSizeSmall:
+        ADDQ $0x01, AX
+
+memmove_emit_remainder_calcBlockSizeSmall:
+        LEAQ (AX)(SI*1), AX
+        JMP  emit_literal_done_emit_remainder_calcBlockSizeSmall
+
+memmove_long_emit_remainder_calcBlockSizeSmall:
+        LEAQ (AX)(SI*1), AX
+
+emit_literal_done_emit_remainder_calcBlockSizeSmall:
+        MOVQ AX, ret+24(FP)
+        RET
+
+// func emitLiteral(dst []byte, lit []byte) int
+// Requires: SSE2
+TEXT ·emitLiteral(SB), NOSPLIT, $0-56
+        MOVQ  lit_len+32(FP), DX
+        MOVQ  dst_base+0(FP), AX
+        MOVQ  lit_base+24(FP), CX
+        TESTQ DX, DX
+        JZ    emit_literal_end_standalone_skip
+        MOVL  DX, BX
+        LEAL  -1(DX), SI
+        CMPL  SI, $0x3c
+        JB    one_byte_standalone
+        CMPL  SI, $0x00000100
+        JB    two_bytes_standalone
+        CMPL  SI, $0x00010000
+        JB    three_bytes_standalone
+        CMPL  SI, $0x01000000
+        JB    four_bytes_standalone
+        MOVB  $0xfc, (AX)
+        MOVL  SI, 1(AX)
+        ADDQ  $0x05, BX
+        ADDQ  $0x05, AX
+        JMP   memmove_long_standalone
+
+four_bytes_standalone:
+        MOVL SI, DI
+        SHRL $0x10, DI
+        MOVB $0xf8, (AX)
+        MOVW SI, 1(AX)
+        MOVB DI, 3(AX)
+        ADDQ $0x04, BX
+        ADDQ $0x04, AX
+        JMP  memmove_long_standalone
+
+three_bytes_standalone:
+        MOVB $0xf4, (AX)
+        MOVW SI, 1(AX)
+        ADDQ $0x03, BX
+        ADDQ $0x03, AX
+        JMP  memmove_long_standalone
+
+two_bytes_standalone:
+        MOVB $0xf0, (AX)
+        MOVB SI, 1(AX)
+        ADDQ $0x02, BX
+        ADDQ $0x02, AX
+        CMPL SI, $0x40
+        JB   memmove_standalone
+        JMP  memmove_long_standalone
+
+one_byte_standalone:
+        SHLB $0x02, SI
+        MOVB SI, (AX)
+        ADDQ $0x01, BX
+        ADDQ $0x01, AX
+
+memmove_standalone:
+        // genMemMoveShort
+        CMPQ DX, $0x03
+        JB   emit_lit_memmove_standalone_memmove_move_1or2
+        JE   emit_lit_memmove_standalone_memmove_move_3
+        CMPQ DX, $0x08
+        JB   emit_lit_memmove_standalone_memmove_move_4through7
+        CMPQ DX, $0x10
+        JBE  emit_lit_memmove_standalone_memmove_move_8through16
+        CMPQ DX, $0x20
+        JBE  emit_lit_memmove_standalone_memmove_move_17through32
+        JMP  emit_lit_memmove_standalone_memmove_move_33through64
+
+emit_lit_memmove_standalone_memmove_move_1or2:
+        MOVB (CX), SI
+        MOVB -1(CX)(DX*1), CL
+        MOVB SI, (AX)
+        MOVB CL, -1(AX)(DX*1)
+        JMP  emit_literal_end_standalone
+
+emit_lit_memmove_standalone_memmove_move_3:
+        MOVW (CX), SI
+        MOVB 2(CX), CL
+        MOVW SI, (AX)
+        MOVB CL, 2(AX)
+        JMP  emit_literal_end_standalone
+
+emit_lit_memmove_standalone_memmove_move_4through7:
+        MOVL (CX), SI
+        MOVL -4(CX)(DX*1), CX
+        MOVL SI, (AX)
+        MOVL CX, -4(AX)(DX*1)
+        JMP  emit_literal_end_standalone
+
+emit_lit_memmove_standalone_memmove_move_8through16:
+        MOVQ (CX), SI
+        MOVQ -8(CX)(DX*1), CX
+        MOVQ SI, (AX)
+        MOVQ CX, -8(AX)(DX*1)
+        JMP  emit_literal_end_standalone
+
+emit_lit_memmove_standalone_memmove_move_17through32:
+        MOVOU (CX), X0
+        MOVOU -16(CX)(DX*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(DX*1)
+        JMP   emit_literal_end_standalone
+
+emit_lit_memmove_standalone_memmove_move_33through64:
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(DX*1), X2
+        MOVOU -16(CX)(DX*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(DX*1)
+        MOVOU X3, -16(AX)(DX*1)
+        JMP   emit_literal_end_standalone
+        JMP emit_literal_end_standalone
+
+memmove_long_standalone:
+        // genMemMoveLong
+        MOVOU (CX), X0
+        MOVOU 16(CX), X1
+        MOVOU -32(CX)(DX*1), X2
+        MOVOU -16(CX)(DX*1), X3
+        MOVQ  DX, DI
+        SHRQ  $0x05, DI
+        MOVQ  AX, SI
+        ANDL  $0x0000001f, SI
+        MOVQ  $0x00000040, R8
+        SUBQ  SI, R8
+        DECQ  DI
+        JA    emit_lit_memmove_long_standalonelarge_forward_sse_loop_32
+        LEAQ  -32(CX)(R8*1), SI
+        LEAQ  -32(AX)(R8*1), R9
+
+emit_lit_memmove_long_standalonelarge_big_loop_back:
+        MOVOU (SI), X4
+        MOVOU 16(SI), X5
+        MOVOA X4, (R9)
+        MOVOA X5, 16(R9)
+        ADDQ  $0x20, R9
+        ADDQ  $0x20, SI
+        ADDQ  $0x20, R8
+        DECQ  DI
+        JNA   emit_lit_memmove_long_standalonelarge_big_loop_back
+
+emit_lit_memmove_long_standalonelarge_forward_sse_loop_32:
+        MOVOU -32(CX)(R8*1), X4
+        MOVOU -16(CX)(R8*1), X5
+        MOVOA X4, -32(AX)(R8*1)
+        MOVOA X5, -16(AX)(R8*1)
+        ADDQ  $0x20, R8
+        CMPQ  DX, R8
+        JAE   emit_lit_memmove_long_standalonelarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(DX*1)
+        MOVOU X3, -16(AX)(DX*1)
+        JMP   emit_literal_end_standalone
+        JMP emit_literal_end_standalone
+
+emit_literal_end_standalone_skip:
+        XORQ BX, BX
+
+emit_literal_end_standalone:
+        MOVQ BX, ret+48(FP)
+        RET
+
+// func emitRepeat(dst []byte, offset int, length int) int
+TEXT ·emitRepeat(SB), NOSPLIT, $0-48
+        XORQ BX, BX
+        MOVQ dst_base+0(FP), AX
+        MOVQ offset+24(FP), CX
+        MOVQ length+32(FP), DX
+
+        // emitRepeat
+emit_repeat_again_standalone:
+        MOVL DX, SI
+        LEAL -4(DX), DX
+        CMPL SI, $0x08
+        JBE  repeat_two_standalone
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_standalone
+        CMPL CX, $0x00000800
+        JB   repeat_two_offset_standalone
+
+cant_repeat_two_offset_standalone:
+        CMPL DX, $0x00000104
+        JB   repeat_three_standalone
+        CMPL DX, $0x00010100
+        JB   repeat_four_standalone
+        CMPL DX, $0x0100ffff
+        JB   repeat_five_standalone
+        LEAL -16842747(DX), DX
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        ADDQ $0x05, BX
+        JMP  emit_repeat_again_standalone
+
+repeat_five_standalone:
+        LEAL -65536(DX), DX
+        MOVL DX, CX
+        MOVW $0x001d, (AX)
+        MOVW DX, 2(AX)
+        SARL $0x10, CX
+        MOVB CL, 4(AX)
+        ADDQ $0x05, BX
+        ADDQ $0x05, AX
+        JMP  gen_emit_repeat_end
+
+repeat_four_standalone:
+        LEAL -256(DX), DX
+        MOVW $0x0019, (AX)
+        MOVW DX, 2(AX)
+        ADDQ $0x04, BX
+        ADDQ $0x04, AX
+        JMP  gen_emit_repeat_end
+
+repeat_three_standalone:
+        LEAL -4(DX), DX
+        MOVW $0x0015, (AX)
+        MOVB DL, 2(AX)
+        ADDQ $0x03, BX
+        ADDQ $0x03, AX
+        JMP  gen_emit_repeat_end
+
+repeat_two_standalone:
+        SHLL $0x02, DX
+        ORL  $0x01, DX
+        MOVW DX, (AX)
+        ADDQ $0x02, BX
+        ADDQ $0x02, AX
+        JMP  gen_emit_repeat_end
+
+repeat_two_offset_standalone:
+        XORQ SI, SI
+        LEAL 1(SI)(DX*4), DX
+        MOVB CL, 1(AX)
+        SARL $0x08, CX
+        SHLL $0x05, CX
+        ORL  CX, DX
+        MOVB DL, (AX)
+        ADDQ $0x02, BX
+        ADDQ $0x02, AX
+
+gen_emit_repeat_end:
+        MOVQ BX, ret+40(FP)
+        RET
+
+// func emitCopy(dst []byte, offset int, length int) int
+TEXT ·emitCopy(SB), NOSPLIT, $0-48
+        XORQ BX, BX
+        MOVQ dst_base+0(FP), AX
+        MOVQ offset+24(FP), CX
+        MOVQ length+32(FP), DX
+
+        // emitCopy
+        CMPL CX, $0x00010000
+        JB   two_byte_offset_standalone
+        CMPL DX, $0x40
+        JBE  four_bytes_remain_standalone
+        MOVB $0xff, (AX)
+        MOVL CX, 1(AX)
+        LEAL -64(DX), DX
+        ADDQ $0x05, BX
+        ADDQ $0x05, AX
+        CMPL DX, $0x04
+        JB   four_bytes_remain_standalone
+
+        // emitRepeat
+emit_repeat_again_standalone_emit_copy:
+        MOVL DX, SI
+        LEAL -4(DX), DX
+        CMPL SI, $0x08
+        JBE  repeat_two_standalone_emit_copy
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_standalone_emit_copy
+        CMPL CX, $0x00000800
+        JB   repeat_two_offset_standalone_emit_copy
+
+cant_repeat_two_offset_standalone_emit_copy:
+        CMPL DX, $0x00000104
+        JB   repeat_three_standalone_emit_copy
+        CMPL DX, $0x00010100
+        JB   repeat_four_standalone_emit_copy
+        CMPL DX, $0x0100ffff
+        JB   repeat_five_standalone_emit_copy
+        LEAL -16842747(DX), DX
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        ADDQ $0x05, BX
+        JMP  emit_repeat_again_standalone_emit_copy
+
+repeat_five_standalone_emit_copy:
+        LEAL -65536(DX), DX
+        MOVL DX, CX
+        MOVW $0x001d, (AX)
+        MOVW DX, 2(AX)
+        SARL $0x10, CX
+        MOVB CL, 4(AX)
+        ADDQ $0x05, BX
+        ADDQ $0x05, AX
+        JMP  gen_emit_copy_end
+
+repeat_four_standalone_emit_copy:
+        LEAL -256(DX), DX
+        MOVW $0x0019, (AX)
+        MOVW DX, 2(AX)
+        ADDQ $0x04, BX
+        ADDQ $0x04, AX
+        JMP  gen_emit_copy_end
+
+repeat_three_standalone_emit_copy:
+        LEAL -4(DX), DX
+        MOVW $0x0015, (AX)
+        MOVB DL, 2(AX)
+        ADDQ $0x03, BX
+        ADDQ $0x03, AX
+        JMP  gen_emit_copy_end
+
+repeat_two_standalone_emit_copy:
+        SHLL $0x02, DX
+        ORL  $0x01, DX
+        MOVW DX, (AX)
+        ADDQ $0x02, BX
+        ADDQ $0x02, AX
+        JMP  gen_emit_copy_end
+
+repeat_two_offset_standalone_emit_copy:
+        XORQ SI, SI
+        LEAL 1(SI)(DX*4), DX
+        MOVB CL, 1(AX)
+        SARL $0x08, CX
+        SHLL $0x05, CX
+        ORL  CX, DX
+        MOVB DL, (AX)
+        ADDQ $0x02, BX
+        ADDQ $0x02, AX
+        JMP  gen_emit_copy_end
+
+four_bytes_remain_standalone:
+        TESTL DX, DX
+        JZ    gen_emit_copy_end
+        XORL  SI, SI
+        LEAL  -1(SI)(DX*4), DX
+        MOVB  DL, (AX)
+        MOVL  CX, 1(AX)
+        ADDQ  $0x05, BX
+        ADDQ  $0x05, AX
+        JMP   gen_emit_copy_end
+
+two_byte_offset_standalone:
+        CMPL DX, $0x40
+        JBE  two_byte_offset_short_standalone
+        CMPL CX, $0x00000800
+        JAE  long_offset_short_standalone
+        MOVL $0x00000001, SI
+        LEAL 16(SI), SI
+        MOVB CL, 1(AX)
+        MOVL CX, DI
+        SHRL $0x08, DI
+        SHLL $0x05, DI
+        ORL  DI, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, BX
+        ADDQ $0x02, AX
+        SUBL $0x08, DX
+
+        // emitRepeat
+        LEAL -4(DX), DX
+        JMP  cant_repeat_two_offset_standalone_emit_copy_short_2b
+
+emit_repeat_again_standalone_emit_copy_short_2b:
+        MOVL DX, SI
+        LEAL -4(DX), DX
+        CMPL SI, $0x08
+        JBE  repeat_two_standalone_emit_copy_short_2b
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_standalone_emit_copy_short_2b
+        CMPL CX, $0x00000800
+        JB   repeat_two_offset_standalone_emit_copy_short_2b
+
+cant_repeat_two_offset_standalone_emit_copy_short_2b:
+        CMPL DX, $0x00000104
+        JB   repeat_three_standalone_emit_copy_short_2b
+        CMPL DX, $0x00010100
+        JB   repeat_four_standalone_emit_copy_short_2b
+        CMPL DX, $0x0100ffff
+        JB   repeat_five_standalone_emit_copy_short_2b
+        LEAL -16842747(DX), DX
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        ADDQ $0x05, BX
+        JMP  emit_repeat_again_standalone_emit_copy_short_2b
+
+repeat_five_standalone_emit_copy_short_2b:
+        LEAL -65536(DX), DX
+        MOVL DX, CX
+        MOVW $0x001d, (AX)
+        MOVW DX, 2(AX)
+        SARL $0x10, CX
+        MOVB CL, 4(AX)
+        ADDQ $0x05, BX
+        ADDQ $0x05, AX
+        JMP  gen_emit_copy_end
+
+repeat_four_standalone_emit_copy_short_2b:
+        LEAL -256(DX), DX
+        MOVW $0x0019, (AX)
+        MOVW DX, 2(AX)
+        ADDQ $0x04, BX
+        ADDQ $0x04, AX
+        JMP  gen_emit_copy_end
+
+repeat_three_standalone_emit_copy_short_2b:
+        LEAL -4(DX), DX
+        MOVW $0x0015, (AX)
+        MOVB DL, 2(AX)
+        ADDQ $0x03, BX
+        ADDQ $0x03, AX
+        JMP  gen_emit_copy_end
+
+repeat_two_standalone_emit_copy_short_2b:
+        SHLL $0x02, DX
+        ORL  $0x01, DX
+        MOVW DX, (AX)
+        ADDQ $0x02, BX
+        ADDQ $0x02, AX
+        JMP  gen_emit_copy_end
+
+repeat_two_offset_standalone_emit_copy_short_2b:
+        XORQ SI, SI
+        LEAL 1(SI)(DX*4), DX
+        MOVB CL, 1(AX)
+        SARL $0x08, CX
+        SHLL $0x05, CX
+        ORL  CX, DX
+        MOVB DL, (AX)
+        ADDQ $0x02, BX
+        ADDQ $0x02, AX
+        JMP  gen_emit_copy_end
+
+long_offset_short_standalone:
+        MOVB $0xee, (AX)
+        MOVW CX, 1(AX)
+        LEAL -60(DX), DX
+        ADDQ $0x03, AX
+        ADDQ $0x03, BX
+
+        // emitRepeat
+emit_repeat_again_standalone_emit_copy_short:
+        MOVL DX, SI
+        LEAL -4(DX), DX
+        CMPL SI, $0x08
+        JBE  repeat_two_standalone_emit_copy_short
+        CMPL SI, $0x0c
+        JAE  cant_repeat_two_offset_standalone_emit_copy_short
+        CMPL CX, $0x00000800
+        JB   repeat_two_offset_standalone_emit_copy_short
+
+cant_repeat_two_offset_standalone_emit_copy_short:
+        CMPL DX, $0x00000104
+        JB   repeat_three_standalone_emit_copy_short
+        CMPL DX, $0x00010100
+        JB   repeat_four_standalone_emit_copy_short
+        CMPL DX, $0x0100ffff
+        JB   repeat_five_standalone_emit_copy_short
+        LEAL -16842747(DX), DX
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        ADDQ $0x05, BX
+        JMP  emit_repeat_again_standalone_emit_copy_short
+
+repeat_five_standalone_emit_copy_short:
+        LEAL -65536(DX), DX
+        MOVL DX, CX
+        MOVW $0x001d, (AX)
+        MOVW DX, 2(AX)
+        SARL $0x10, CX
+        MOVB CL, 4(AX)
+        ADDQ $0x05, BX
+        ADDQ $0x05, AX
+        JMP  gen_emit_copy_end
+
+repeat_four_standalone_emit_copy_short:
+        LEAL -256(DX), DX
+        MOVW $0x0019, (AX)
+        MOVW DX, 2(AX)
+        ADDQ $0x04, BX
+        ADDQ $0x04, AX
+        JMP  gen_emit_copy_end
+
+repeat_three_standalone_emit_copy_short:
+        LEAL -4(DX), DX
+        MOVW $0x0015, (AX)
+        MOVB DL, 2(AX)
+        ADDQ $0x03, BX
+        ADDQ $0x03, AX
+        JMP  gen_emit_copy_end
+
+repeat_two_standalone_emit_copy_short:
+        SHLL $0x02, DX
+        ORL  $0x01, DX
+        MOVW DX, (AX)
+        ADDQ $0x02, BX
+        ADDQ $0x02, AX
+        JMP  gen_emit_copy_end
+
+repeat_two_offset_standalone_emit_copy_short:
+        XORQ SI, SI
+        LEAL 1(SI)(DX*4), DX
+        MOVB CL, 1(AX)
+        SARL $0x08, CX
+        SHLL $0x05, CX
+        ORL  CX, DX
+        MOVB DL, (AX)
+        ADDQ $0x02, BX
+        ADDQ $0x02, AX
+        JMP  gen_emit_copy_end
+
+two_byte_offset_short_standalone:
+        MOVL DX, SI
+        SHLL $0x02, SI
+        CMPL DX, $0x0c
+        JAE  emit_copy_three_standalone
+        CMPL CX, $0x00000800
+        JAE  emit_copy_three_standalone
+        LEAL -15(SI), SI
+        MOVB CL, 1(AX)
+        SHRL $0x08, CX
+        SHLL $0x05, CX
+        ORL  CX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, BX
+        ADDQ $0x02, AX
+        JMP  gen_emit_copy_end
+
+emit_copy_three_standalone:
+        LEAL -2(SI), SI
+        MOVB SI, (AX)
+        MOVW CX, 1(AX)
+        ADDQ $0x03, BX
+        ADDQ $0x03, AX
+
+gen_emit_copy_end:
+        MOVQ BX, ret+40(FP)
+        RET
+
+// func emitCopyNoRepeat(dst []byte, offset int, length int) int
+TEXT ·emitCopyNoRepeat(SB), NOSPLIT, $0-48
+        XORQ BX, BX
+        MOVQ dst_base+0(FP), AX
+        MOVQ offset+24(FP), CX
+        MOVQ length+32(FP), DX
+
+        // emitCopy
+        CMPL CX, $0x00010000
+        JB   two_byte_offset_standalone_snappy
+
+four_bytes_loop_back_standalone_snappy:
+        CMPL DX, $0x40
+        JBE  four_bytes_remain_standalone_snappy
+        MOVB $0xff, (AX)
+        MOVL CX, 1(AX)
+        LEAL -64(DX), DX
+        ADDQ $0x05, BX
+        ADDQ $0x05, AX
+        CMPL DX, $0x04
+        JB   four_bytes_remain_standalone_snappy
+        JMP  four_bytes_loop_back_standalone_snappy
+
+four_bytes_remain_standalone_snappy:
+        TESTL DX, DX
+        JZ    gen_emit_copy_end_snappy
+        XORL  SI, SI
+        LEAL  -1(SI)(DX*4), DX
+        MOVB  DL, (AX)
+        MOVL  CX, 1(AX)
+        ADDQ  $0x05, BX
+        ADDQ  $0x05, AX
+        JMP   gen_emit_copy_end_snappy
+
+two_byte_offset_standalone_snappy:
+        CMPL DX, $0x40
+        JBE  two_byte_offset_short_standalone_snappy
+        MOVB $0xee, (AX)
+        MOVW CX, 1(AX)
+        LEAL -60(DX), DX
+        ADDQ $0x03, AX
+        ADDQ $0x03, BX
+        JMP  two_byte_offset_standalone_snappy
+
+two_byte_offset_short_standalone_snappy:
+        MOVL DX, SI
+        SHLL $0x02, SI
+        CMPL DX, $0x0c
+        JAE  emit_copy_three_standalone_snappy
+        CMPL CX, $0x00000800
+        JAE  emit_copy_three_standalone_snappy
+        LEAL -15(SI), SI
+        MOVB CL, 1(AX)
+        SHRL $0x08, CX
+        SHLL $0x05, CX
+        ORL  CX, SI
+        MOVB SI, (AX)
+        ADDQ $0x02, BX
+        ADDQ $0x02, AX
+        JMP  gen_emit_copy_end_snappy
+
+emit_copy_three_standalone_snappy:
+        LEAL -2(SI), SI
+        MOVB SI, (AX)
+        MOVW CX, 1(AX)
+        ADDQ $0x03, BX
+        ADDQ $0x03, AX
+
+gen_emit_copy_end_snappy:
+        MOVQ BX, ret+40(FP)
+        RET
+
+// func matchLen(a []byte, b []byte) int
+// Requires: BMI
+TEXT ·matchLen(SB), NOSPLIT, $0-56
+        MOVQ a_base+0(FP), AX
+        MOVQ b_base+24(FP), CX
+        MOVQ a_len+8(FP), DX
+
+        // matchLen
+        XORL SI, SI
+
+matchlen_loopback_16_standalone:
+        CMPL DX, $0x10
+        JB   matchlen_match8_standalone
+        MOVQ (AX)(SI*1), BX
+        MOVQ 8(AX)(SI*1), DI
+        XORQ (CX)(SI*1), BX
+        JNZ  matchlen_bsf_8_standalone
+        XORQ 8(CX)(SI*1), DI
+        JNZ  matchlen_bsf_16standalone
+        LEAL -16(DX), DX
+        LEAL 16(SI), SI
+        JMP  matchlen_loopback_16_standalone
+
+matchlen_bsf_16standalone:
+#ifdef GOAMD64_v3
+        TZCNTQ DI, DI
+
+#else
+        BSFQ DI, DI
+
+#endif
+        SARQ $0x03, DI
+        LEAL 8(SI)(DI*1), SI
+        JMP  gen_match_len_end
+
+matchlen_match8_standalone:
+        CMPL DX, $0x08
+        JB   matchlen_match4_standalone
+        MOVQ (AX)(SI*1), BX
+        XORQ (CX)(SI*1), BX
+        JNZ  matchlen_bsf_8_standalone
+        LEAL -8(DX), DX
+        LEAL 8(SI), SI
+        JMP  matchlen_match4_standalone
+
+matchlen_bsf_8_standalone:
+#ifdef GOAMD64_v3
+        TZCNTQ BX, BX
+
+#else
+        BSFQ BX, BX
+
+#endif
+        SARQ $0x03, BX
+        LEAL (SI)(BX*1), SI
+        JMP  gen_match_len_end
+
+matchlen_match4_standalone:
+        CMPL DX, $0x04
+        JB   matchlen_match2_standalone
+        MOVL (AX)(SI*1), BX
+        CMPL (CX)(SI*1), BX
+        JNE  matchlen_match2_standalone
+        LEAL -4(DX), DX
+        LEAL 4(SI), SI
+
+matchlen_match2_standalone:
+        CMPL DX, $0x01
+        JE   matchlen_match1_standalone
+        JB   gen_match_len_end
+        MOVW (AX)(SI*1), BX
+        CMPW (CX)(SI*1), BX
+        JNE  matchlen_match1_standalone
+        LEAL 2(SI), SI
+        SUBL $0x02, DX
+        JZ   gen_match_len_end
+
+matchlen_match1_standalone:
+        MOVB (AX)(SI*1), BL
+        CMPB (CX)(SI*1), BL
+        JNE  gen_match_len_end
+        LEAL 1(SI), SI
+
+gen_match_len_end:
+        MOVQ SI, ret+48(FP)
+        RET
+
+// func cvtLZ4BlockAsm(dst []byte, src []byte) (uncompressed int, dstUsed int)
+// Requires: SSE2
+TEXT ·cvtLZ4BlockAsm(SB), NOSPLIT, $0-64
+        XORQ SI, SI
+        MOVQ dst_base+0(FP), AX
+        MOVQ dst_len+8(FP), CX
+        MOVQ src_base+24(FP), DX
+        MOVQ src_len+32(FP), BX
+        LEAQ (DX)(BX*1), BX
+        LEAQ -10(AX)(CX*1), CX
+        XORQ DI, DI
+
+lz4_s2_loop:
+        CMPQ    DX, BX
+        JAE     lz4_s2_corrupt
+        CMPQ    AX, CX
+        JAE     lz4_s2_dstfull
+        MOVBQZX (DX), R8
+        MOVQ    R8, R9
+        MOVQ    R8, R10
+        SHRQ    $0x04, R9
+        ANDQ    $0x0f, R10
+        CMPQ    R8, $0xf0
+        JB      lz4_s2_ll_end
+
+lz4_s2_ll_loop:
+        INCQ    DX
+        CMPQ    DX, BX
+        JAE     lz4_s2_corrupt
+        MOVBQZX (DX), R8
+        ADDQ    R8, R9
+        CMPQ    R8, $0xff
+        JEQ     lz4_s2_ll_loop
+
+lz4_s2_ll_end:
+        LEAQ  (DX)(R9*1), R8
+        ADDQ  $0x04, R10
+        CMPQ  R8, BX
+        JAE   lz4_s2_corrupt
+        INCQ  DX
+        INCQ  R8
+        TESTQ R9, R9
+        JZ    lz4_s2_lits_done
+        LEAQ  (AX)(R9*1), R11
+        CMPQ  R11, CX
+        JAE   lz4_s2_dstfull
+        ADDQ  R9, SI
+        LEAL  -1(R9), R11
+        CMPL  R11, $0x3c
+        JB    one_byte_lz4_s2
+        CMPL  R11, $0x00000100
+        JB    two_bytes_lz4_s2
+        CMPL  R11, $0x00010000
+        JB    three_bytes_lz4_s2
+        CMPL  R11, $0x01000000
+        JB    four_bytes_lz4_s2
+        MOVB  $0xfc, (AX)
+        MOVL  R11, 1(AX)
+        ADDQ  $0x05, AX
+        JMP   memmove_long_lz4_s2
+
+four_bytes_lz4_s2:
+        MOVL R11, R12
+        SHRL $0x10, R12
+        MOVB $0xf8, (AX)
+        MOVW R11, 1(AX)
+        MOVB R12, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_lz4_s2
+
+three_bytes_lz4_s2:
+        MOVB $0xf4, (AX)
+        MOVW R11, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_lz4_s2
+
+two_bytes_lz4_s2:
+        MOVB $0xf0, (AX)
+        MOVB R11, 1(AX)
+        ADDQ $0x02, AX
+        CMPL R11, $0x40
+        JB   memmove_lz4_s2
+        JMP  memmove_long_lz4_s2
+
+one_byte_lz4_s2:
+        SHLB $0x02, R11
+        MOVB R11, (AX)
+        ADDQ $0x01, AX
+
+memmove_lz4_s2:
+        LEAQ (AX)(R9*1), R11
+
+        // genMemMoveShort
+        CMPQ R9, $0x08
+        JBE  emit_lit_memmove_lz4_s2_memmove_move_8
+        CMPQ R9, $0x10
+        JBE  emit_lit_memmove_lz4_s2_memmove_move_8through16
+        CMPQ R9, $0x20
+        JBE  emit_lit_memmove_lz4_s2_memmove_move_17through32
+        JMP  emit_lit_memmove_lz4_s2_memmove_move_33through64
+
+emit_lit_memmove_lz4_s2_memmove_move_8:
+        MOVQ (DX), R12
+        MOVQ R12, (AX)
+        JMP  memmove_end_copy_lz4_s2
+
+emit_lit_memmove_lz4_s2_memmove_move_8through16:
+        MOVQ (DX), R12
+        MOVQ -8(DX)(R9*1), DX
+        MOVQ R12, (AX)
+        MOVQ DX, -8(AX)(R9*1)
+        JMP  memmove_end_copy_lz4_s2
+
+emit_lit_memmove_lz4_s2_memmove_move_17through32:
+        MOVOU (DX), X0
+        MOVOU -16(DX)(R9*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R9*1)
+        JMP   memmove_end_copy_lz4_s2
+
+emit_lit_memmove_lz4_s2_memmove_move_33through64:
+        MOVOU (DX), X0
+        MOVOU 16(DX), X1
+        MOVOU -32(DX)(R9*1), X2
+        MOVOU -16(DX)(R9*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R9*1)
+        MOVOU X3, -16(AX)(R9*1)
+
+memmove_end_copy_lz4_s2:
+        MOVQ R11, AX
+        JMP  lz4_s2_lits_emit_done
+
+memmove_long_lz4_s2:
+        LEAQ (AX)(R9*1), R11
+
+        // genMemMoveLong
+        MOVOU (DX), X0
+        MOVOU 16(DX), X1
+        MOVOU -32(DX)(R9*1), X2
+        MOVOU -16(DX)(R9*1), X3
+        MOVQ  R9, R13
+        SHRQ  $0x05, R13
+        MOVQ  AX, R12
+        ANDL  $0x0000001f, R12
+        MOVQ  $0x00000040, R14
+        SUBQ  R12, R14
+        DECQ  R13
+        JA    emit_lit_memmove_long_lz4_s2large_forward_sse_loop_32
+        LEAQ  -32(DX)(R14*1), R12
+        LEAQ  -32(AX)(R14*1), R15
+
+emit_lit_memmove_long_lz4_s2large_big_loop_back:
+        MOVOU (R12), X4
+        MOVOU 16(R12), X5
+        MOVOA X4, (R15)
+        MOVOA X5, 16(R15)
+        ADDQ  $0x20, R15
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R14
+        DECQ  R13
+        JNA   emit_lit_memmove_long_lz4_s2large_big_loop_back
+
+emit_lit_memmove_long_lz4_s2large_forward_sse_loop_32:
+        MOVOU -32(DX)(R14*1), X4
+        MOVOU -16(DX)(R14*1), X5
+        MOVOA X4, -32(AX)(R14*1)
+        MOVOA X5, -16(AX)(R14*1)
+        ADDQ  $0x20, R14
+        CMPQ  R9, R14
+        JAE   emit_lit_memmove_long_lz4_s2large_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R9*1)
+        MOVOU X3, -16(AX)(R9*1)
+        MOVQ  R11, AX
+
+lz4_s2_lits_emit_done:
+        MOVQ R8, DX
+
+lz4_s2_lits_done:
+        CMPQ DX, BX
+        JNE  lz4_s2_match
+        CMPQ R10, $0x04
+        JEQ  lz4_s2_done
+        JMP  lz4_s2_corrupt
+
+lz4_s2_match:
+        LEAQ    2(DX), R8
+        CMPQ    R8, BX
+        JAE     lz4_s2_corrupt
+        MOVWQZX (DX), R9
+        MOVQ    R8, DX
+        TESTQ   R9, R9
+        JZ      lz4_s2_corrupt
+        CMPQ    R9, SI
+        JA      lz4_s2_corrupt
+        CMPQ    R10, $0x13
+        JNE     lz4_s2_ml_done
+
+lz4_s2_ml_loop:
+        MOVBQZX (DX), R8
+        INCQ    DX
+        ADDQ    R8, R10
+        CMPQ    DX, BX
+        JAE     lz4_s2_corrupt
+        CMPQ    R8, $0xff
+        JEQ     lz4_s2_ml_loop
+
+lz4_s2_ml_done:
+        ADDQ R10, SI
+        CMPQ R9, DI
+        JNE  lz4_s2_docopy
+
+        // emitRepeat
+emit_repeat_again_lz4_s2:
+        MOVL R10, R8
+        LEAL -4(R10), R10
+        CMPL R8, $0x08
+        JBE  repeat_two_lz4_s2
+        CMPL R8, $0x0c
+        JAE  cant_repeat_two_offset_lz4_s2
+        CMPL R9, $0x00000800
+        JB   repeat_two_offset_lz4_s2
+
+cant_repeat_two_offset_lz4_s2:
+        CMPL R10, $0x00000104
+        JB   repeat_three_lz4_s2
+        CMPL R10, $0x00010100
+        JB   repeat_four_lz4_s2
+        CMPL R10, $0x0100ffff
+        JB   repeat_five_lz4_s2
+        LEAL -16842747(R10), R10
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_lz4_s2
+
+repeat_five_lz4_s2:
+        LEAL -65536(R10), R10
+        MOVL R10, R9
+        MOVW $0x001d, (AX)
+        MOVW R10, 2(AX)
+        SARL $0x10, R9
+        MOVB R9, 4(AX)
+        ADDQ $0x05, AX
+        JMP  lz4_s2_loop
+
+repeat_four_lz4_s2:
+        LEAL -256(R10), R10
+        MOVW $0x0019, (AX)
+        MOVW R10, 2(AX)
+        ADDQ $0x04, AX
+        JMP  lz4_s2_loop
+
+repeat_three_lz4_s2:
+        LEAL -4(R10), R10
+        MOVW $0x0015, (AX)
+        MOVB R10, 2(AX)
+        ADDQ $0x03, AX
+        JMP  lz4_s2_loop
+
+repeat_two_lz4_s2:
+        SHLL $0x02, R10
+        ORL  $0x01, R10
+        MOVW R10, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4_s2_loop
+
+repeat_two_offset_lz4_s2:
+        XORQ R8, R8
+        LEAL 1(R8)(R10*4), R10
+        MOVB R9, 1(AX)
+        SARL $0x08, R9
+        SHLL $0x05, R9
+        ORL  R9, R10
+        MOVB R10, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4_s2_loop
+
+lz4_s2_docopy:
+        MOVQ R9, DI
+
+        // emitCopy
+        CMPL R10, $0x40
+        JBE  two_byte_offset_short_lz4_s2
+        CMPL R9, $0x00000800
+        JAE  long_offset_short_lz4_s2
+        MOVL $0x00000001, R8
+        LEAL 16(R8), R8
+        MOVB R9, 1(AX)
+        MOVL R9, R11
+        SHRL $0x08, R11
+        SHLL $0x05, R11
+        ORL  R11, R8
+        MOVB R8, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, R10
+
+        // emitRepeat
+        LEAL -4(R10), R10
+        JMP  cant_repeat_two_offset_lz4_s2_emit_copy_short_2b
+
+emit_repeat_again_lz4_s2_emit_copy_short_2b:
+        MOVL R10, R8
+        LEAL -4(R10), R10
+        CMPL R8, $0x08
+        JBE  repeat_two_lz4_s2_emit_copy_short_2b
+        CMPL R8, $0x0c
+        JAE  cant_repeat_two_offset_lz4_s2_emit_copy_short_2b
+        CMPL R9, $0x00000800
+        JB   repeat_two_offset_lz4_s2_emit_copy_short_2b
+
+cant_repeat_two_offset_lz4_s2_emit_copy_short_2b:
+        CMPL R10, $0x00000104
+        JB   repeat_three_lz4_s2_emit_copy_short_2b
+        CMPL R10, $0x00010100
+        JB   repeat_four_lz4_s2_emit_copy_short_2b
+        CMPL R10, $0x0100ffff
+        JB   repeat_five_lz4_s2_emit_copy_short_2b
+        LEAL -16842747(R10), R10
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_lz4_s2_emit_copy_short_2b
+
+repeat_five_lz4_s2_emit_copy_short_2b:
+        LEAL -65536(R10), R10
+        MOVL R10, R9
+        MOVW $0x001d, (AX)
+        MOVW R10, 2(AX)
+        SARL $0x10, R9
+        MOVB R9, 4(AX)
+        ADDQ $0x05, AX
+        JMP  lz4_s2_loop
+
+repeat_four_lz4_s2_emit_copy_short_2b:
+        LEAL -256(R10), R10
+        MOVW $0x0019, (AX)
+        MOVW R10, 2(AX)
+        ADDQ $0x04, AX
+        JMP  lz4_s2_loop
+
+repeat_three_lz4_s2_emit_copy_short_2b:
+        LEAL -4(R10), R10
+        MOVW $0x0015, (AX)
+        MOVB R10, 2(AX)
+        ADDQ $0x03, AX
+        JMP  lz4_s2_loop
+
+repeat_two_lz4_s2_emit_copy_short_2b:
+        SHLL $0x02, R10
+        ORL  $0x01, R10
+        MOVW R10, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4_s2_loop
+
+repeat_two_offset_lz4_s2_emit_copy_short_2b:
+        XORQ R8, R8
+        LEAL 1(R8)(R10*4), R10
+        MOVB R9, 1(AX)
+        SARL $0x08, R9
+        SHLL $0x05, R9
+        ORL  R9, R10
+        MOVB R10, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4_s2_loop
+
+long_offset_short_lz4_s2:
+        MOVB $0xee, (AX)
+        MOVW R9, 1(AX)
+        LEAL -60(R10), R10
+        ADDQ $0x03, AX
+
+        // emitRepeat
+emit_repeat_again_lz4_s2_emit_copy_short:
+        MOVL R10, R8
+        LEAL -4(R10), R10
+        CMPL R8, $0x08
+        JBE  repeat_two_lz4_s2_emit_copy_short
+        CMPL R8, $0x0c
+        JAE  cant_repeat_two_offset_lz4_s2_emit_copy_short
+        CMPL R9, $0x00000800
+        JB   repeat_two_offset_lz4_s2_emit_copy_short
+
+cant_repeat_two_offset_lz4_s2_emit_copy_short:
+        CMPL R10, $0x00000104
+        JB   repeat_three_lz4_s2_emit_copy_short
+        CMPL R10, $0x00010100
+        JB   repeat_four_lz4_s2_emit_copy_short
+        CMPL R10, $0x0100ffff
+        JB   repeat_five_lz4_s2_emit_copy_short
+        LEAL -16842747(R10), R10
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_lz4_s2_emit_copy_short
+
+repeat_five_lz4_s2_emit_copy_short:
+        LEAL -65536(R10), R10
+        MOVL R10, R9
+        MOVW $0x001d, (AX)
+        MOVW R10, 2(AX)
+        SARL $0x10, R9
+        MOVB R9, 4(AX)
+        ADDQ $0x05, AX
+        JMP  lz4_s2_loop
+
+repeat_four_lz4_s2_emit_copy_short:
+        LEAL -256(R10), R10
+        MOVW $0x0019, (AX)
+        MOVW R10, 2(AX)
+        ADDQ $0x04, AX
+        JMP  lz4_s2_loop
+
+repeat_three_lz4_s2_emit_copy_short:
+        LEAL -4(R10), R10
+        MOVW $0x0015, (AX)
+        MOVB R10, 2(AX)
+        ADDQ $0x03, AX
+        JMP  lz4_s2_loop
+
+repeat_two_lz4_s2_emit_copy_short:
+        SHLL $0x02, R10
+        ORL  $0x01, R10
+        MOVW R10, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4_s2_loop
+
+repeat_two_offset_lz4_s2_emit_copy_short:
+        XORQ R8, R8
+        LEAL 1(R8)(R10*4), R10
+        MOVB R9, 1(AX)
+        SARL $0x08, R9
+        SHLL $0x05, R9
+        ORL  R9, R10
+        MOVB R10, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4_s2_loop
+
+two_byte_offset_short_lz4_s2:
+        MOVL R10, R8
+        SHLL $0x02, R8
+        CMPL R10, $0x0c
+        JAE  emit_copy_three_lz4_s2
+        CMPL R9, $0x00000800
+        JAE  emit_copy_three_lz4_s2
+        LEAL -15(R8), R8
+        MOVB R9, 1(AX)
+        SHRL $0x08, R9
+        SHLL $0x05, R9
+        ORL  R9, R8
+        MOVB R8, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4_s2_loop
+
+emit_copy_three_lz4_s2:
+        LEAL -2(R8), R8
+        MOVB R8, (AX)
+        MOVW R9, 1(AX)
+        ADDQ $0x03, AX
+        JMP  lz4_s2_loop
+
+lz4_s2_done:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ SI, uncompressed+48(FP)
+        MOVQ AX, dstUsed+56(FP)
+        RET
+
+lz4_s2_corrupt:
+        XORQ AX, AX
+        LEAQ -1(AX), SI
+        MOVQ SI, uncompressed+48(FP)
+        RET
+
+lz4_s2_dstfull:
+        XORQ AX, AX
+        LEAQ -2(AX), SI
+        MOVQ SI, uncompressed+48(FP)
+        RET
+
+// func cvtLZ4sBlockAsm(dst []byte, src []byte) (uncompressed int, dstUsed int)
+// Requires: SSE2
+TEXT ·cvtLZ4sBlockAsm(SB), NOSPLIT, $0-64
+        XORQ SI, SI
+        MOVQ dst_base+0(FP), AX
+        MOVQ dst_len+8(FP), CX
+        MOVQ src_base+24(FP), DX
+        MOVQ src_len+32(FP), BX
+        LEAQ (DX)(BX*1), BX
+        LEAQ -10(AX)(CX*1), CX
+        XORQ DI, DI
+
+lz4s_s2_loop:
+        CMPQ    DX, BX
+        JAE     lz4s_s2_corrupt
+        CMPQ    AX, CX
+        JAE     lz4s_s2_dstfull
+        MOVBQZX (DX), R8
+        MOVQ    R8, R9
+        MOVQ    R8, R10
+        SHRQ    $0x04, R9
+        ANDQ    $0x0f, R10
+        CMPQ    R8, $0xf0
+        JB      lz4s_s2_ll_end
+
+lz4s_s2_ll_loop:
+        INCQ    DX
+        CMPQ    DX, BX
+        JAE     lz4s_s2_corrupt
+        MOVBQZX (DX), R8
+        ADDQ    R8, R9
+        CMPQ    R8, $0xff
+        JEQ     lz4s_s2_ll_loop
+
+lz4s_s2_ll_end:
+        LEAQ  (DX)(R9*1), R8
+        ADDQ  $0x03, R10
+        CMPQ  R8, BX
+        JAE   lz4s_s2_corrupt
+        INCQ  DX
+        INCQ  R8
+        TESTQ R9, R9
+        JZ    lz4s_s2_lits_done
+        LEAQ  (AX)(R9*1), R11
+        CMPQ  R11, CX
+        JAE   lz4s_s2_dstfull
+        ADDQ  R9, SI
+        LEAL  -1(R9), R11
+        CMPL  R11, $0x3c
+        JB    one_byte_lz4s_s2
+        CMPL  R11, $0x00000100
+        JB    two_bytes_lz4s_s2
+        CMPL  R11, $0x00010000
+        JB    three_bytes_lz4s_s2
+        CMPL  R11, $0x01000000
+        JB    four_bytes_lz4s_s2
+        MOVB  $0xfc, (AX)
+        MOVL  R11, 1(AX)
+        ADDQ  $0x05, AX
+        JMP   memmove_long_lz4s_s2
+
+four_bytes_lz4s_s2:
+        MOVL R11, R12
+        SHRL $0x10, R12
+        MOVB $0xf8, (AX)
+        MOVW R11, 1(AX)
+        MOVB R12, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_lz4s_s2
+
+three_bytes_lz4s_s2:
+        MOVB $0xf4, (AX)
+        MOVW R11, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_lz4s_s2
+
+two_bytes_lz4s_s2:
+        MOVB $0xf0, (AX)
+        MOVB R11, 1(AX)
+        ADDQ $0x02, AX
+        CMPL R11, $0x40
+        JB   memmove_lz4s_s2
+        JMP  memmove_long_lz4s_s2
+
+one_byte_lz4s_s2:
+        SHLB $0x02, R11
+        MOVB R11, (AX)
+        ADDQ $0x01, AX
+
+memmove_lz4s_s2:
+        LEAQ (AX)(R9*1), R11
+
+        // genMemMoveShort
+        CMPQ R9, $0x08
+        JBE  emit_lit_memmove_lz4s_s2_memmove_move_8
+        CMPQ R9, $0x10
+        JBE  emit_lit_memmove_lz4s_s2_memmove_move_8through16
+        CMPQ R9, $0x20
+        JBE  emit_lit_memmove_lz4s_s2_memmove_move_17through32
+        JMP  emit_lit_memmove_lz4s_s2_memmove_move_33through64
+
+emit_lit_memmove_lz4s_s2_memmove_move_8:
+        MOVQ (DX), R12
+        MOVQ R12, (AX)
+        JMP  memmove_end_copy_lz4s_s2
+
+emit_lit_memmove_lz4s_s2_memmove_move_8through16:
+        MOVQ (DX), R12
+        MOVQ -8(DX)(R9*1), DX
+        MOVQ R12, (AX)
+        MOVQ DX, -8(AX)(R9*1)
+        JMP  memmove_end_copy_lz4s_s2
+
+emit_lit_memmove_lz4s_s2_memmove_move_17through32:
+        MOVOU (DX), X0
+        MOVOU -16(DX)(R9*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R9*1)
+        JMP   memmove_end_copy_lz4s_s2
+
+emit_lit_memmove_lz4s_s2_memmove_move_33through64:
+        MOVOU (DX), X0
+        MOVOU 16(DX), X1
+        MOVOU -32(DX)(R9*1), X2
+        MOVOU -16(DX)(R9*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R9*1)
+        MOVOU X3, -16(AX)(R9*1)
+
+memmove_end_copy_lz4s_s2:
+        MOVQ R11, AX
+        JMP  lz4s_s2_lits_emit_done
+
+memmove_long_lz4s_s2:
+        LEAQ (AX)(R9*1), R11
+
+        // genMemMoveLong
+        MOVOU (DX), X0
+        MOVOU 16(DX), X1
+        MOVOU -32(DX)(R9*1), X2
+        MOVOU -16(DX)(R9*1), X3
+        MOVQ  R9, R13
+        SHRQ  $0x05, R13
+        MOVQ  AX, R12
+        ANDL  $0x0000001f, R12
+        MOVQ  $0x00000040, R14
+        SUBQ  R12, R14
+        DECQ  R13
+        JA    emit_lit_memmove_long_lz4s_s2large_forward_sse_loop_32
+        LEAQ  -32(DX)(R14*1), R12
+        LEAQ  -32(AX)(R14*1), R15
+
+emit_lit_memmove_long_lz4s_s2large_big_loop_back:
+        MOVOU (R12), X4
+        MOVOU 16(R12), X5
+        MOVOA X4, (R15)
+        MOVOA X5, 16(R15)
+        ADDQ  $0x20, R15
+        ADDQ  $0x20, R12
+        ADDQ  $0x20, R14
+        DECQ  R13
+        JNA   emit_lit_memmove_long_lz4s_s2large_big_loop_back
+
+emit_lit_memmove_long_lz4s_s2large_forward_sse_loop_32:
+        MOVOU -32(DX)(R14*1), X4
+        MOVOU -16(DX)(R14*1), X5
+        MOVOA X4, -32(AX)(R14*1)
+        MOVOA X5, -16(AX)(R14*1)
+        ADDQ  $0x20, R14
+        CMPQ  R9, R14
+        JAE   emit_lit_memmove_long_lz4s_s2large_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R9*1)
+        MOVOU X3, -16(AX)(R9*1)
+        MOVQ  R11, AX
+
+lz4s_s2_lits_emit_done:
+        MOVQ R8, DX
+
+lz4s_s2_lits_done:
+        CMPQ DX, BX
+        JNE  lz4s_s2_match
+        CMPQ R10, $0x03
+        JEQ  lz4s_s2_done
+        JMP  lz4s_s2_corrupt
+
+lz4s_s2_match:
+        CMPQ    R10, $0x03
+        JEQ     lz4s_s2_loop
+        LEAQ    2(DX), R8
+        CMPQ    R8, BX
+        JAE     lz4s_s2_corrupt
+        MOVWQZX (DX), R9
+        MOVQ    R8, DX
+        TESTQ   R9, R9
+        JZ      lz4s_s2_corrupt
+        CMPQ    R9, SI
+        JA      lz4s_s2_corrupt
+        CMPQ    R10, $0x12
+        JNE     lz4s_s2_ml_done
+
+lz4s_s2_ml_loop:
+        MOVBQZX (DX), R8
+        INCQ    DX
+        ADDQ    R8, R10
+        CMPQ    DX, BX
+        JAE     lz4s_s2_corrupt
+        CMPQ    R8, $0xff
+        JEQ     lz4s_s2_ml_loop
+
+lz4s_s2_ml_done:
+        ADDQ R10, SI
+        CMPQ R9, DI
+        JNE  lz4s_s2_docopy
+
+        // emitRepeat
+emit_repeat_again_lz4_s2:
+        MOVL R10, R8
+        LEAL -4(R10), R10
+        CMPL R8, $0x08
+        JBE  repeat_two_lz4_s2
+        CMPL R8, $0x0c
+        JAE  cant_repeat_two_offset_lz4_s2
+        CMPL R9, $0x00000800
+        JB   repeat_two_offset_lz4_s2
+
+cant_repeat_two_offset_lz4_s2:
+        CMPL R10, $0x00000104
+        JB   repeat_three_lz4_s2
+        CMPL R10, $0x00010100
+        JB   repeat_four_lz4_s2
+        CMPL R10, $0x0100ffff
+        JB   repeat_five_lz4_s2
+        LEAL -16842747(R10), R10
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_lz4_s2
+
+repeat_five_lz4_s2:
+        LEAL -65536(R10), R10
+        MOVL R10, R9
+        MOVW $0x001d, (AX)
+        MOVW R10, 2(AX)
+        SARL $0x10, R9
+        MOVB R9, 4(AX)
+        ADDQ $0x05, AX
+        JMP  lz4s_s2_loop
+
+repeat_four_lz4_s2:
+        LEAL -256(R10), R10
+        MOVW $0x0019, (AX)
+        MOVW R10, 2(AX)
+        ADDQ $0x04, AX
+        JMP  lz4s_s2_loop
+
+repeat_three_lz4_s2:
+        LEAL -4(R10), R10
+        MOVW $0x0015, (AX)
+        MOVB R10, 2(AX)
+        ADDQ $0x03, AX
+        JMP  lz4s_s2_loop
+
+repeat_two_lz4_s2:
+        SHLL $0x02, R10
+        ORL  $0x01, R10
+        MOVW R10, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4s_s2_loop
+
+repeat_two_offset_lz4_s2:
+        XORQ R8, R8
+        LEAL 1(R8)(R10*4), R10
+        MOVB R9, 1(AX)
+        SARL $0x08, R9
+        SHLL $0x05, R9
+        ORL  R9, R10
+        MOVB R10, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4s_s2_loop
+
+lz4s_s2_docopy:
+        MOVQ R9, DI
+
+        // emitCopy
+        CMPL R10, $0x40
+        JBE  two_byte_offset_short_lz4_s2
+        CMPL R9, $0x00000800
+        JAE  long_offset_short_lz4_s2
+        MOVL $0x00000001, R8
+        LEAL 16(R8), R8
+        MOVB R9, 1(AX)
+        MOVL R9, R11
+        SHRL $0x08, R11
+        SHLL $0x05, R11
+        ORL  R11, R8
+        MOVB R8, (AX)
+        ADDQ $0x02, AX
+        SUBL $0x08, R10
+
+        // emitRepeat
+        LEAL -4(R10), R10
+        JMP  cant_repeat_two_offset_lz4_s2_emit_copy_short_2b
+
+emit_repeat_again_lz4_s2_emit_copy_short_2b:
+        MOVL R10, R8
+        LEAL -4(R10), R10
+        CMPL R8, $0x08
+        JBE  repeat_two_lz4_s2_emit_copy_short_2b
+        CMPL R8, $0x0c
+        JAE  cant_repeat_two_offset_lz4_s2_emit_copy_short_2b
+        CMPL R9, $0x00000800
+        JB   repeat_two_offset_lz4_s2_emit_copy_short_2b
+
+cant_repeat_two_offset_lz4_s2_emit_copy_short_2b:
+        CMPL R10, $0x00000104
+        JB   repeat_three_lz4_s2_emit_copy_short_2b
+        CMPL R10, $0x00010100
+        JB   repeat_four_lz4_s2_emit_copy_short_2b
+        CMPL R10, $0x0100ffff
+        JB   repeat_five_lz4_s2_emit_copy_short_2b
+        LEAL -16842747(R10), R10
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_lz4_s2_emit_copy_short_2b
+
+repeat_five_lz4_s2_emit_copy_short_2b:
+        LEAL -65536(R10), R10
+        MOVL R10, R9
+        MOVW $0x001d, (AX)
+        MOVW R10, 2(AX)
+        SARL $0x10, R9
+        MOVB R9, 4(AX)
+        ADDQ $0x05, AX
+        JMP  lz4s_s2_loop
+
+repeat_four_lz4_s2_emit_copy_short_2b:
+        LEAL -256(R10), R10
+        MOVW $0x0019, (AX)
+        MOVW R10, 2(AX)
+        ADDQ $0x04, AX
+        JMP  lz4s_s2_loop
+
+repeat_three_lz4_s2_emit_copy_short_2b:
+        LEAL -4(R10), R10
+        MOVW $0x0015, (AX)
+        MOVB R10, 2(AX)
+        ADDQ $0x03, AX
+        JMP  lz4s_s2_loop
+
+repeat_two_lz4_s2_emit_copy_short_2b:
+        SHLL $0x02, R10
+        ORL  $0x01, R10
+        MOVW R10, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4s_s2_loop
+
+repeat_two_offset_lz4_s2_emit_copy_short_2b:
+        XORQ R8, R8
+        LEAL 1(R8)(R10*4), R10
+        MOVB R9, 1(AX)
+        SARL $0x08, R9
+        SHLL $0x05, R9
+        ORL  R9, R10
+        MOVB R10, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4s_s2_loop
+
+long_offset_short_lz4_s2:
+        MOVB $0xee, (AX)
+        MOVW R9, 1(AX)
+        LEAL -60(R10), R10
+        ADDQ $0x03, AX
+
+        // emitRepeat
+emit_repeat_again_lz4_s2_emit_copy_short:
+        MOVL R10, R8
+        LEAL -4(R10), R10
+        CMPL R8, $0x08
+        JBE  repeat_two_lz4_s2_emit_copy_short
+        CMPL R8, $0x0c
+        JAE  cant_repeat_two_offset_lz4_s2_emit_copy_short
+        CMPL R9, $0x00000800
+        JB   repeat_two_offset_lz4_s2_emit_copy_short
+
+cant_repeat_two_offset_lz4_s2_emit_copy_short:
+        CMPL R10, $0x00000104
+        JB   repeat_three_lz4_s2_emit_copy_short
+        CMPL R10, $0x00010100
+        JB   repeat_four_lz4_s2_emit_copy_short
+        CMPL R10, $0x0100ffff
+        JB   repeat_five_lz4_s2_emit_copy_short
+        LEAL -16842747(R10), R10
+        MOVL $0xfffb001d, (AX)
+        MOVB $0xff, 4(AX)
+        ADDQ $0x05, AX
+        JMP  emit_repeat_again_lz4_s2_emit_copy_short
+
+repeat_five_lz4_s2_emit_copy_short:
+        LEAL -65536(R10), R10
+        MOVL R10, R9
+        MOVW $0x001d, (AX)
+        MOVW R10, 2(AX)
+        SARL $0x10, R9
+        MOVB R9, 4(AX)
+        ADDQ $0x05, AX
+        JMP  lz4s_s2_loop
+
+repeat_four_lz4_s2_emit_copy_short:
+        LEAL -256(R10), R10
+        MOVW $0x0019, (AX)
+        MOVW R10, 2(AX)
+        ADDQ $0x04, AX
+        JMP  lz4s_s2_loop
+
+repeat_three_lz4_s2_emit_copy_short:
+        LEAL -4(R10), R10
+        MOVW $0x0015, (AX)
+        MOVB R10, 2(AX)
+        ADDQ $0x03, AX
+        JMP  lz4s_s2_loop
+
+repeat_two_lz4_s2_emit_copy_short:
+        SHLL $0x02, R10
+        ORL  $0x01, R10
+        MOVW R10, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4s_s2_loop
+
+repeat_two_offset_lz4_s2_emit_copy_short:
+        XORQ R8, R8
+        LEAL 1(R8)(R10*4), R10
+        MOVB R9, 1(AX)
+        SARL $0x08, R9
+        SHLL $0x05, R9
+        ORL  R9, R10
+        MOVB R10, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4s_s2_loop
+
+two_byte_offset_short_lz4_s2:
+        MOVL R10, R8
+        SHLL $0x02, R8
+        CMPL R10, $0x0c
+        JAE  emit_copy_three_lz4_s2
+        CMPL R9, $0x00000800
+        JAE  emit_copy_three_lz4_s2
+        LEAL -15(R8), R8
+        MOVB R9, 1(AX)
+        SHRL $0x08, R9
+        SHLL $0x05, R9
+        ORL  R9, R8
+        MOVB R8, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4s_s2_loop
+
+emit_copy_three_lz4_s2:
+        LEAL -2(R8), R8
+        MOVB R8, (AX)
+        MOVW R9, 1(AX)
+        ADDQ $0x03, AX
+        JMP  lz4s_s2_loop
+
+lz4s_s2_done:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ SI, uncompressed+48(FP)
+        MOVQ AX, dstUsed+56(FP)
+        RET
+
+lz4s_s2_corrupt:
+        XORQ AX, AX
+        LEAQ -1(AX), SI
+        MOVQ SI, uncompressed+48(FP)
+        RET
+
+lz4s_s2_dstfull:
+        XORQ AX, AX
+        LEAQ -2(AX), SI
+        MOVQ SI, uncompressed+48(FP)
+        RET
+
+// func cvtLZ4BlockSnappyAsm(dst []byte, src []byte) (uncompressed int, dstUsed int)
+// Requires: SSE2
+TEXT ·cvtLZ4BlockSnappyAsm(SB), NOSPLIT, $0-64
+        XORQ SI, SI
+        MOVQ dst_base+0(FP), AX
+        MOVQ dst_len+8(FP), CX
+        MOVQ src_base+24(FP), DX
+        MOVQ src_len+32(FP), BX
+        LEAQ (DX)(BX*1), BX
+        LEAQ -10(AX)(CX*1), CX
+
+lz4_snappy_loop:
+        CMPQ    DX, BX
+        JAE     lz4_snappy_corrupt
+        CMPQ    AX, CX
+        JAE     lz4_snappy_dstfull
+        MOVBQZX (DX), DI
+        MOVQ    DI, R8
+        MOVQ    DI, R9
+        SHRQ    $0x04, R8
+        ANDQ    $0x0f, R9
+        CMPQ    DI, $0xf0
+        JB      lz4_snappy_ll_end
+
+lz4_snappy_ll_loop:
+        INCQ    DX
+        CMPQ    DX, BX
+        JAE     lz4_snappy_corrupt
+        MOVBQZX (DX), DI
+        ADDQ    DI, R8
+        CMPQ    DI, $0xff
+        JEQ     lz4_snappy_ll_loop
+
+lz4_snappy_ll_end:
+        LEAQ  (DX)(R8*1), DI
+        ADDQ  $0x04, R9
+        CMPQ  DI, BX
+        JAE   lz4_snappy_corrupt
+        INCQ  DX
+        INCQ  DI
+        TESTQ R8, R8
+        JZ    lz4_snappy_lits_done
+        LEAQ  (AX)(R8*1), R10
+        CMPQ  R10, CX
+        JAE   lz4_snappy_dstfull
+        ADDQ  R8, SI
+        LEAL  -1(R8), R10
+        CMPL  R10, $0x3c
+        JB    one_byte_lz4_snappy
+        CMPL  R10, $0x00000100
+        JB    two_bytes_lz4_snappy
+        CMPL  R10, $0x00010000
+        JB    three_bytes_lz4_snappy
+        CMPL  R10, $0x01000000
+        JB    four_bytes_lz4_snappy
+        MOVB  $0xfc, (AX)
+        MOVL  R10, 1(AX)
+        ADDQ  $0x05, AX
+        JMP   memmove_long_lz4_snappy
+
+four_bytes_lz4_snappy:
+        MOVL R10, R11
+        SHRL $0x10, R11
+        MOVB $0xf8, (AX)
+        MOVW R10, 1(AX)
+        MOVB R11, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_lz4_snappy
+
+three_bytes_lz4_snappy:
+        MOVB $0xf4, (AX)
+        MOVW R10, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_lz4_snappy
+
+two_bytes_lz4_snappy:
+        MOVB $0xf0, (AX)
+        MOVB R10, 1(AX)
+        ADDQ $0x02, AX
+        CMPL R10, $0x40
+        JB   memmove_lz4_snappy
+        JMP  memmove_long_lz4_snappy
+
+one_byte_lz4_snappy:
+        SHLB $0x02, R10
+        MOVB R10, (AX)
+        ADDQ $0x01, AX
+
+memmove_lz4_snappy:
+        LEAQ (AX)(R8*1), R10
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_lz4_snappy_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_lz4_snappy_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_lz4_snappy_memmove_move_17through32
+        JMP  emit_lit_memmove_lz4_snappy_memmove_move_33through64
+
+emit_lit_memmove_lz4_snappy_memmove_move_8:
+        MOVQ (DX), R11
+        MOVQ R11, (AX)
+        JMP  memmove_end_copy_lz4_snappy
+
+emit_lit_memmove_lz4_snappy_memmove_move_8through16:
+        MOVQ (DX), R11
+        MOVQ -8(DX)(R8*1), DX
+        MOVQ R11, (AX)
+        MOVQ DX, -8(AX)(R8*1)
+        JMP  memmove_end_copy_lz4_snappy
+
+emit_lit_memmove_lz4_snappy_memmove_move_17through32:
+        MOVOU (DX), X0
+        MOVOU -16(DX)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_lz4_snappy
+
+emit_lit_memmove_lz4_snappy_memmove_move_33through64:
+        MOVOU (DX), X0
+        MOVOU 16(DX), X1
+        MOVOU -32(DX)(R8*1), X2
+        MOVOU -16(DX)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_lz4_snappy:
+        MOVQ R10, AX
+        JMP  lz4_snappy_lits_emit_done
+
+memmove_long_lz4_snappy:
+        LEAQ (AX)(R8*1), R10
+
+        // genMemMoveLong
+        MOVOU (DX), X0
+        MOVOU 16(DX), X1
+        MOVOU -32(DX)(R8*1), X2
+        MOVOU -16(DX)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R11
+        ANDL  $0x0000001f, R11
+        MOVQ  $0x00000040, R13
+        SUBQ  R11, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_lz4_snappylarge_forward_sse_loop_32
+        LEAQ  -32(DX)(R13*1), R11
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_lz4_snappylarge_big_loop_back:
+        MOVOU (R11), X4
+        MOVOU 16(R11), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R11
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_lz4_snappylarge_big_loop_back
+
+emit_lit_memmove_long_lz4_snappylarge_forward_sse_loop_32:
+        MOVOU -32(DX)(R13*1), X4
+        MOVOU -16(DX)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_lz4_snappylarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  R10, AX
+
+lz4_snappy_lits_emit_done:
+        MOVQ DI, DX
+
+lz4_snappy_lits_done:
+        CMPQ DX, BX
+        JNE  lz4_snappy_match
+        CMPQ R9, $0x04
+        JEQ  lz4_snappy_done
+        JMP  lz4_snappy_corrupt
+
+lz4_snappy_match:
+        LEAQ    2(DX), DI
+        CMPQ    DI, BX
+        JAE     lz4_snappy_corrupt
+        MOVWQZX (DX), R8
+        MOVQ    DI, DX
+        TESTQ   R8, R8
+        JZ      lz4_snappy_corrupt
+        CMPQ    R8, SI
+        JA      lz4_snappy_corrupt
+        CMPQ    R9, $0x13
+        JNE     lz4_snappy_ml_done
+
+lz4_snappy_ml_loop:
+        MOVBQZX (DX), DI
+        INCQ    DX
+        ADDQ    DI, R9
+        CMPQ    DX, BX
+        JAE     lz4_snappy_corrupt
+        CMPQ    DI, $0xff
+        JEQ     lz4_snappy_ml_loop
+
+lz4_snappy_ml_done:
+        ADDQ R9, SI
+
+        // emitCopy
+two_byte_offset_lz4_s2:
+        CMPL R9, $0x40
+        JBE  two_byte_offset_short_lz4_s2
+        MOVB $0xee, (AX)
+        MOVW R8, 1(AX)
+        LEAL -60(R9), R9
+        ADDQ $0x03, AX
+        CMPQ AX, CX
+        JAE  lz4_snappy_loop
+        JMP  two_byte_offset_lz4_s2
+
+two_byte_offset_short_lz4_s2:
+        MOVL R9, DI
+        SHLL $0x02, DI
+        CMPL R9, $0x0c
+        JAE  emit_copy_three_lz4_s2
+        CMPL R8, $0x00000800
+        JAE  emit_copy_three_lz4_s2
+        LEAL -15(DI), DI
+        MOVB R8, 1(AX)
+        SHRL $0x08, R8
+        SHLL $0x05, R8
+        ORL  R8, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4_snappy_loop
+
+emit_copy_three_lz4_s2:
+        LEAL -2(DI), DI
+        MOVB DI, (AX)
+        MOVW R8, 1(AX)
+        ADDQ $0x03, AX
+        JMP  lz4_snappy_loop
+
+lz4_snappy_done:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ SI, uncompressed+48(FP)
+        MOVQ AX, dstUsed+56(FP)
+        RET
+
+lz4_snappy_corrupt:
+        XORQ AX, AX
+        LEAQ -1(AX), SI
+        MOVQ SI, uncompressed+48(FP)
+        RET
+
+lz4_snappy_dstfull:
+        XORQ AX, AX
+        LEAQ -2(AX), SI
+        MOVQ SI, uncompressed+48(FP)
+        RET
+
+// func cvtLZ4sBlockSnappyAsm(dst []byte, src []byte) (uncompressed int, dstUsed int)
+// Requires: SSE2
+TEXT ·cvtLZ4sBlockSnappyAsm(SB), NOSPLIT, $0-64
+        XORQ SI, SI
+        MOVQ dst_base+0(FP), AX
+        MOVQ dst_len+8(FP), CX
+        MOVQ src_base+24(FP), DX
+        MOVQ src_len+32(FP), BX
+        LEAQ (DX)(BX*1), BX
+        LEAQ -10(AX)(CX*1), CX
+
+lz4s_snappy_loop:
+        CMPQ    DX, BX
+        JAE     lz4s_snappy_corrupt
+        CMPQ    AX, CX
+        JAE     lz4s_snappy_dstfull
+        MOVBQZX (DX), DI
+        MOVQ    DI, R8
+        MOVQ    DI, R9
+        SHRQ    $0x04, R8
+        ANDQ    $0x0f, R9
+        CMPQ    DI, $0xf0
+        JB      lz4s_snappy_ll_end
+
+lz4s_snappy_ll_loop:
+        INCQ    DX
+        CMPQ    DX, BX
+        JAE     lz4s_snappy_corrupt
+        MOVBQZX (DX), DI
+        ADDQ    DI, R8
+        CMPQ    DI, $0xff
+        JEQ     lz4s_snappy_ll_loop
+
+lz4s_snappy_ll_end:
+        LEAQ  (DX)(R8*1), DI
+        ADDQ  $0x03, R9
+        CMPQ  DI, BX
+        JAE   lz4s_snappy_corrupt
+        INCQ  DX
+        INCQ  DI
+        TESTQ R8, R8
+        JZ    lz4s_snappy_lits_done
+        LEAQ  (AX)(R8*1), R10
+        CMPQ  R10, CX
+        JAE   lz4s_snappy_dstfull
+        ADDQ  R8, SI
+        LEAL  -1(R8), R10
+        CMPL  R10, $0x3c
+        JB    one_byte_lz4s_snappy
+        CMPL  R10, $0x00000100
+        JB    two_bytes_lz4s_snappy
+        CMPL  R10, $0x00010000
+        JB    three_bytes_lz4s_snappy
+        CMPL  R10, $0x01000000
+        JB    four_bytes_lz4s_snappy
+        MOVB  $0xfc, (AX)
+        MOVL  R10, 1(AX)
+        ADDQ  $0x05, AX
+        JMP   memmove_long_lz4s_snappy
+
+four_bytes_lz4s_snappy:
+        MOVL R10, R11
+        SHRL $0x10, R11
+        MOVB $0xf8, (AX)
+        MOVW R10, 1(AX)
+        MOVB R11, 3(AX)
+        ADDQ $0x04, AX
+        JMP  memmove_long_lz4s_snappy
+
+three_bytes_lz4s_snappy:
+        MOVB $0xf4, (AX)
+        MOVW R10, 1(AX)
+        ADDQ $0x03, AX
+        JMP  memmove_long_lz4s_snappy
+
+two_bytes_lz4s_snappy:
+        MOVB $0xf0, (AX)
+        MOVB R10, 1(AX)
+        ADDQ $0x02, AX
+        CMPL R10, $0x40
+        JB   memmove_lz4s_snappy
+        JMP  memmove_long_lz4s_snappy
+
+one_byte_lz4s_snappy:
+        SHLB $0x02, R10
+        MOVB R10, (AX)
+        ADDQ $0x01, AX
+
+memmove_lz4s_snappy:
+        LEAQ (AX)(R8*1), R10
+
+        // genMemMoveShort
+        CMPQ R8, $0x08
+        JBE  emit_lit_memmove_lz4s_snappy_memmove_move_8
+        CMPQ R8, $0x10
+        JBE  emit_lit_memmove_lz4s_snappy_memmove_move_8through16
+        CMPQ R8, $0x20
+        JBE  emit_lit_memmove_lz4s_snappy_memmove_move_17through32
+        JMP  emit_lit_memmove_lz4s_snappy_memmove_move_33through64
+
+emit_lit_memmove_lz4s_snappy_memmove_move_8:
+        MOVQ (DX), R11
+        MOVQ R11, (AX)
+        JMP  memmove_end_copy_lz4s_snappy
+
+emit_lit_memmove_lz4s_snappy_memmove_move_8through16:
+        MOVQ (DX), R11
+        MOVQ -8(DX)(R8*1), DX
+        MOVQ R11, (AX)
+        MOVQ DX, -8(AX)(R8*1)
+        JMP  memmove_end_copy_lz4s_snappy
+
+emit_lit_memmove_lz4s_snappy_memmove_move_17through32:
+        MOVOU (DX), X0
+        MOVOU -16(DX)(R8*1), X1
+        MOVOU X0, (AX)
+        MOVOU X1, -16(AX)(R8*1)
+        JMP   memmove_end_copy_lz4s_snappy
+
+emit_lit_memmove_lz4s_snappy_memmove_move_33through64:
+        MOVOU (DX), X0
+        MOVOU 16(DX), X1
+        MOVOU -32(DX)(R8*1), X2
+        MOVOU -16(DX)(R8*1), X3
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+
+memmove_end_copy_lz4s_snappy:
+        MOVQ R10, AX
+        JMP  lz4s_snappy_lits_emit_done
+
+memmove_long_lz4s_snappy:
+        LEAQ (AX)(R8*1), R10
+
+        // genMemMoveLong
+        MOVOU (DX), X0
+        MOVOU 16(DX), X1
+        MOVOU -32(DX)(R8*1), X2
+        MOVOU -16(DX)(R8*1), X3
+        MOVQ  R8, R12
+        SHRQ  $0x05, R12
+        MOVQ  AX, R11
+        ANDL  $0x0000001f, R11
+        MOVQ  $0x00000040, R13
+        SUBQ  R11, R13
+        DECQ  R12
+        JA    emit_lit_memmove_long_lz4s_snappylarge_forward_sse_loop_32
+        LEAQ  -32(DX)(R13*1), R11
+        LEAQ  -32(AX)(R13*1), R14
+
+emit_lit_memmove_long_lz4s_snappylarge_big_loop_back:
+        MOVOU (R11), X4
+        MOVOU 16(R11), X5
+        MOVOA X4, (R14)
+        MOVOA X5, 16(R14)
+        ADDQ  $0x20, R14
+        ADDQ  $0x20, R11
+        ADDQ  $0x20, R13
+        DECQ  R12
+        JNA   emit_lit_memmove_long_lz4s_snappylarge_big_loop_back
+
+emit_lit_memmove_long_lz4s_snappylarge_forward_sse_loop_32:
+        MOVOU -32(DX)(R13*1), X4
+        MOVOU -16(DX)(R13*1), X5
+        MOVOA X4, -32(AX)(R13*1)
+        MOVOA X5, -16(AX)(R13*1)
+        ADDQ  $0x20, R13
+        CMPQ  R8, R13
+        JAE   emit_lit_memmove_long_lz4s_snappylarge_forward_sse_loop_32
+        MOVOU X0, (AX)
+        MOVOU X1, 16(AX)
+        MOVOU X2, -32(AX)(R8*1)
+        MOVOU X3, -16(AX)(R8*1)
+        MOVQ  R10, AX
+
+lz4s_snappy_lits_emit_done:
+        MOVQ DI, DX
+
+lz4s_snappy_lits_done:
+        CMPQ DX, BX
+        JNE  lz4s_snappy_match
+        CMPQ R9, $0x03
+        JEQ  lz4s_snappy_done
+        JMP  lz4s_snappy_corrupt
+
+lz4s_snappy_match:
+        CMPQ    R9, $0x03
+        JEQ     lz4s_snappy_loop
+        LEAQ    2(DX), DI
+        CMPQ    DI, BX
+        JAE     lz4s_snappy_corrupt
+        MOVWQZX (DX), R8
+        MOVQ    DI, DX
+        TESTQ   R8, R8
+        JZ      lz4s_snappy_corrupt
+        CMPQ    R8, SI
+        JA      lz4s_snappy_corrupt
+        CMPQ    R9, $0x12
+        JNE     lz4s_snappy_ml_done
+
+lz4s_snappy_ml_loop:
+        MOVBQZX (DX), DI
+        INCQ    DX
+        ADDQ    DI, R9
+        CMPQ    DX, BX
+        JAE     lz4s_snappy_corrupt
+        CMPQ    DI, $0xff
+        JEQ     lz4s_snappy_ml_loop
+
+lz4s_snappy_ml_done:
+        ADDQ R9, SI
+
+        // emitCopy
+two_byte_offset_lz4_s2:
+        CMPL R9, $0x40
+        JBE  two_byte_offset_short_lz4_s2
+        MOVB $0xee, (AX)
+        MOVW R8, 1(AX)
+        LEAL -60(R9), R9
+        ADDQ $0x03, AX
+        CMPQ AX, CX
+        JAE  lz4s_snappy_loop
+        JMP  two_byte_offset_lz4_s2
+
+two_byte_offset_short_lz4_s2:
+        MOVL R9, DI
+        SHLL $0x02, DI
+        CMPL R9, $0x0c
+        JAE  emit_copy_three_lz4_s2
+        CMPL R8, $0x00000800
+        JAE  emit_copy_three_lz4_s2
+        LEAL -15(DI), DI
+        MOVB R8, 1(AX)
+        SHRL $0x08, R8
+        SHLL $0x05, R8
+        ORL  R8, DI
+        MOVB DI, (AX)
+        ADDQ $0x02, AX
+        JMP  lz4s_snappy_loop
+
+emit_copy_three_lz4_s2:
+        LEAL -2(DI), DI
+        MOVB DI, (AX)
+        MOVW R8, 1(AX)
+        ADDQ $0x03, AX
+        JMP  lz4s_snappy_loop
+
+lz4s_snappy_done:
+        MOVQ dst_base+0(FP), CX
+        SUBQ CX, AX
+        MOVQ SI, uncompressed+48(FP)
+        MOVQ AX, dstUsed+56(FP)
+        RET
+
+lz4s_snappy_corrupt:
+        XORQ AX, AX
+        LEAQ -1(AX), SI
+        MOVQ SI, uncompressed+48(FP)
+        RET
+
+lz4s_snappy_dstfull:
+        XORQ AX, AX
+        LEAQ -2(AX), SI
+        MOVQ SI, uncompressed+48(FP)
+        RET
diff --git a/vendor/github.com/klauspost/compress/s2/index.go b/vendor/github.com/klauspost/compress/s2/index.go
new file mode 100644
index 0000000..18a4f7a
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/index.go
@@ -0,0 +1,596 @@
+// Copyright (c) 2022+ Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s2
+
+import (
+        "bytes"
+        "encoding/binary"
+        "encoding/json"
+        "fmt"
+        "io"
+        "sort"
+)
+
+const (
+        S2IndexHeader   = "s2idx\x00"
+        S2IndexTrailer  = "\x00xdi2s"
+        maxIndexEntries = 1 << 16
+)
+
+// Index represents an S2/Snappy index.
+type Index struct {
+        TotalUncompressed int64 // Total Uncompressed size if known. Will be -1 if unknown.
+        TotalCompressed   int64 // Total Compressed size if known. Will be -1 if unknown.
+        info              []struct {
+                compressedOffset   int64
+                uncompressedOffset int64
+        }
+        estBlockUncomp int64
+}
+
+func (i *Index) reset(maxBlock int) {
+        i.estBlockUncomp = int64(maxBlock)
+        i.TotalCompressed = -1
+        i.TotalUncompressed = -1
+        if len(i.info) > 0 {
+                i.info = i.info[:0]
+        }
+}
+
+// allocInfos will allocate an empty slice of infos.
+func (i *Index) allocInfos(n int) {
+        if n > maxIndexEntries {
+                panic("n > maxIndexEntries")
+        }
+        i.info = make([]struct {
+                compressedOffset   int64
+                uncompressedOffset int64
+        }, 0, n)
+}
+
+// add an uncompressed and compressed pair.
+// Entries must be sent in order.
+func (i *Index) add(compressedOffset, uncompressedOffset int64) error {
+        if i == nil {
+                return nil
+        }
+        lastIdx := len(i.info) - 1
+        if lastIdx >= 0 {
+                latest := i.info[lastIdx]
+                if latest.uncompressedOffset == uncompressedOffset {
+                        // Uncompressed didn't change, don't add entry,
+                        // but update start index.
+                        latest.compressedOffset = compressedOffset
+                        i.info[lastIdx] = latest
+                        return nil
+                }
+                if latest.uncompressedOffset > uncompressedOffset {
+                        return fmt.Errorf("internal error: Earlier uncompressed received (%d > %d)", latest.uncompressedOffset, uncompressedOffset)
+                }
+                if latest.compressedOffset > compressedOffset {
+                        return fmt.Errorf("internal error: Earlier compressed received (%d > %d)", latest.uncompressedOffset, uncompressedOffset)
+                }
+        }
+        i.info = append(i.info, struct {
+                compressedOffset   int64
+                uncompressedOffset int64
+        }{compressedOffset: compressedOffset, uncompressedOffset: uncompressedOffset})
+        return nil
+}
+
+// Find the offset at or before the wanted (uncompressed) offset.
+// If offset is 0 or positive it is the offset from the beginning of the file.
+// If the uncompressed size is known, the offset must be within the file.
+// If an offset outside the file is requested io.ErrUnexpectedEOF is returned.
+// If the offset is negative, it is interpreted as the distance from the end of the file,
+// where -1 represents the last byte.
+// If offset from the end of the file is requested, but size is unknown,
+// ErrUnsupported will be returned.
+func (i *Index) Find(offset int64) (compressedOff, uncompressedOff int64, err error) {
+        if i.TotalUncompressed < 0 {
+                return 0, 0, ErrCorrupt
+        }
+        if offset < 0 {
+                offset = i.TotalUncompressed + offset
+                if offset < 0 {
+                        return 0, 0, io.ErrUnexpectedEOF
+                }
+        }
+        if offset > i.TotalUncompressed {
+                return 0, 0, io.ErrUnexpectedEOF
+        }
+        if len(i.info) > 200 {
+                n := sort.Search(len(i.info), func(n int) bool {
+                        return i.info[n].uncompressedOffset > offset
+                })
+                if n == 0 {
+                        n = 1
+                }
+                return i.info[n-1].compressedOffset, i.info[n-1].uncompressedOffset, nil
+        }
+        for _, info := range i.info {
+                if info.uncompressedOffset > offset {
+                        break
+                }
+                compressedOff = info.compressedOffset
+                uncompressedOff = info.uncompressedOffset
+        }
+        return compressedOff, uncompressedOff, nil
+}
+
+// reduce to stay below maxIndexEntries
+func (i *Index) reduce() {
+        if len(i.info) < maxIndexEntries && i.estBlockUncomp >= 1<<20 {
+                return
+        }
+
+        // Algorithm, keep 1, remove removeN entries...
+        removeN := (len(i.info) + 1) / maxIndexEntries
+        src := i.info
+        j := 0
+
+        // Each block should be at least 1MB, but don't reduce below 1000 entries.
+        for i.estBlockUncomp*(int64(removeN)+1) < 1<<20 && len(i.info)/(removeN+1) > 1000 {
+                removeN++
+        }
+        for idx := 0; idx < len(src); idx++ {
+                i.info[j] = src[idx]
+                j++
+                idx += removeN
+        }
+        i.info = i.info[:j]
+        // Update maxblock estimate.
+        i.estBlockUncomp += i.estBlockUncomp * int64(removeN)
+}
+
+func (i *Index) appendTo(b []byte, uncompTotal, compTotal int64) []byte {
+        i.reduce()
+        var tmp [binary.MaxVarintLen64]byte
+
+        initSize := len(b)
+        // We make the start a skippable header+size.
+        b = append(b, ChunkTypeIndex, 0, 0, 0)
+        b = append(b, []byte(S2IndexHeader)...)
+        // Total Uncompressed size
+        n := binary.PutVarint(tmp[:], uncompTotal)
+        b = append(b, tmp[:n]...)
+        // Total Compressed size
+        n = binary.PutVarint(tmp[:], compTotal)
+        b = append(b, tmp[:n]...)
+        // Put EstBlockUncomp size
+        n = binary.PutVarint(tmp[:], i.estBlockUncomp)
+        b = append(b, tmp[:n]...)
+        // Put length
+        n = binary.PutVarint(tmp[:], int64(len(i.info)))
+        b = append(b, tmp[:n]...)
+
+        // Check if we should add uncompressed offsets
+        var hasUncompressed byte
+        for idx, info := range i.info {
+                if idx == 0 {
+                        if info.uncompressedOffset != 0 {
+                                hasUncompressed = 1
+                                break
+                        }
+                        continue
+                }
+                if info.uncompressedOffset != i.info[idx-1].uncompressedOffset+i.estBlockUncomp {
+                        hasUncompressed = 1
+                        break
+                }
+        }
+        b = append(b, hasUncompressed)
+
+        // Add each entry
+        if hasUncompressed == 1 {
+                for idx, info := range i.info {
+                        uOff := info.uncompressedOffset
+                        if idx > 0 {
+                                prev := i.info[idx-1]
+                                uOff -= prev.uncompressedOffset + (i.estBlockUncomp)
+                        }
+                        n = binary.PutVarint(tmp[:], uOff)
+                        b = append(b, tmp[:n]...)
+                }
+        }
+
+        // Initial compressed size estimate.
+        cPredict := i.estBlockUncomp / 2
+
+        for idx, info := range i.info {
+                cOff := info.compressedOffset
+                if idx > 0 {
+                        prev := i.info[idx-1]
+                        cOff -= prev.compressedOffset + cPredict
+                        // Update compressed size prediction, with half the error.
+                        cPredict += cOff / 2
+                }
+                n = binary.PutVarint(tmp[:], cOff)
+                b = append(b, tmp[:n]...)
+        }
+
+        // Add Total Size.
+        // Stored as fixed size for easier reading.
+        binary.LittleEndian.PutUint32(tmp[:], uint32(len(b)-initSize+4+len(S2IndexTrailer)))
+        b = append(b, tmp[:4]...)
+        // Trailer
+        b = append(b, []byte(S2IndexTrailer)...)
+
+        // Update size
+        chunkLen := len(b) - initSize - skippableFrameHeader
+        b[initSize+1] = uint8(chunkLen >> 0)
+        b[initSize+2] = uint8(chunkLen >> 8)
+        b[initSize+3] = uint8(chunkLen >> 16)
+        //fmt.Printf("chunklen: 0x%x Uncomp:%d, Comp:%d\n", chunkLen, uncompTotal, compTotal)
+        return b
+}
+
+// Load a binary index.
+// A zero value Index can be used or a previous one can be reused.
+func (i *Index) Load(b []byte) ([]byte, error) {
+        if len(b) <= 4+len(S2IndexHeader)+len(S2IndexTrailer) {
+                return b, io.ErrUnexpectedEOF
+        }
+        if b[0] != ChunkTypeIndex {
+                return b, ErrCorrupt
+        }
+        chunkLen := int(b[1]) | int(b[2])<<8 | int(b[3])<<16
+        b = b[4:]
+
+        // Validate we have enough...
+        if len(b) < chunkLen {
+                return b, io.ErrUnexpectedEOF
+        }
+        if !bytes.Equal(b[:len(S2IndexHeader)], []byte(S2IndexHeader)) {
+                return b, ErrUnsupported
+        }
+        b = b[len(S2IndexHeader):]
+
+        // Total Uncompressed
+        if v, n := binary.Varint(b); n <= 0 || v < 0 {
+                return b, ErrCorrupt
+        } else {
+                i.TotalUncompressed = v
+                b = b[n:]
+        }
+
+        // Total Compressed
+        if v, n := binary.Varint(b); n <= 0 {
+                return b, ErrCorrupt
+        } else {
+                i.TotalCompressed = v
+                b = b[n:]
+        }
+
+        // Read EstBlockUncomp
+        if v, n := binary.Varint(b); n <= 0 {
+                return b, ErrCorrupt
+        } else {
+                if v < 0 {
+                        return b, ErrCorrupt
+                }
+                i.estBlockUncomp = v
+                b = b[n:]
+        }
+
+        var entries int
+        if v, n := binary.Varint(b); n <= 0 {
+                return b, ErrCorrupt
+        } else {
+                if v < 0 || v > maxIndexEntries {
+                        return b, ErrCorrupt
+                }
+                entries = int(v)
+                b = b[n:]
+        }
+        if cap(i.info) < entries {
+                i.allocInfos(entries)
+        }
+        i.info = i.info[:entries]
+
+        if len(b) < 1 {
+                return b, io.ErrUnexpectedEOF
+        }
+        hasUncompressed := b[0]
+        b = b[1:]
+        if hasUncompressed&1 != hasUncompressed {
+                return b, ErrCorrupt
+        }
+
+        // Add each uncompressed entry
+        for idx := range i.info {
+                var uOff int64
+                if hasUncompressed != 0 {
+                        // Load delta
+                        if v, n := binary.Varint(b); n <= 0 {
+                                return b, ErrCorrupt
+                        } else {
+                                uOff = v
+                                b = b[n:]
+                        }
+                }
+
+                if idx > 0 {
+                        prev := i.info[idx-1].uncompressedOffset
+                        uOff += prev + (i.estBlockUncomp)
+                        if uOff <= prev {
+                                return b, ErrCorrupt
+                        }
+                }
+                if uOff < 0 {
+                        return b, ErrCorrupt
+                }
+                i.info[idx].uncompressedOffset = uOff
+        }
+
+        // Initial compressed size estimate.
+        cPredict := i.estBlockUncomp / 2
+
+        // Add each compressed entry
+        for idx := range i.info {
+                var cOff int64
+                if v, n := binary.Varint(b); n <= 0 {
+                        return b, ErrCorrupt
+                } else {
+                        cOff = v
+                        b = b[n:]
+                }
+
+                if idx > 0 {
+                        // Update compressed size prediction, with half the error.
+                        cPredictNew := cPredict + cOff/2
+
+                        prev := i.info[idx-1].compressedOffset
+                        cOff += prev + cPredict
+                        if cOff <= prev {
+                                return b, ErrCorrupt
+                        }
+                        cPredict = cPredictNew
+                }
+                if cOff < 0 {
+                        return b, ErrCorrupt
+                }
+                i.info[idx].compressedOffset = cOff
+        }
+        if len(b) < 4+len(S2IndexTrailer) {
+                return b, io.ErrUnexpectedEOF
+        }
+        // Skip size...
+        b = b[4:]
+
+        // Check trailer...
+        if !bytes.Equal(b[:len(S2IndexTrailer)], []byte(S2IndexTrailer)) {
+                return b, ErrCorrupt
+        }
+        return b[len(S2IndexTrailer):], nil
+}
+
+// LoadStream will load an index from the end of the supplied stream.
+// ErrUnsupported will be returned if the signature cannot be found.
+// ErrCorrupt will be returned if unexpected values are found.
+// io.ErrUnexpectedEOF is returned if there are too few bytes.
+// IO errors are returned as-is.
+func (i *Index) LoadStream(rs io.ReadSeeker) error {
+        // Go to end.
+        _, err := rs.Seek(-10, io.SeekEnd)
+        if err != nil {
+                return err
+        }
+        var tmp [10]byte
+        _, err = io.ReadFull(rs, tmp[:])
+        if err != nil {
+                return err
+        }
+        // Check trailer...
+        if !bytes.Equal(tmp[4:4+len(S2IndexTrailer)], []byte(S2IndexTrailer)) {
+                return ErrUnsupported
+        }
+        sz := binary.LittleEndian.Uint32(tmp[:4])
+        if sz > maxChunkSize+skippableFrameHeader {
+                return ErrCorrupt
+        }
+        _, err = rs.Seek(-int64(sz), io.SeekEnd)
+        if err != nil {
+                return err
+        }
+
+        // Read index.
+        buf := make([]byte, sz)
+        _, err = io.ReadFull(rs, buf)
+        if err != nil {
+                return err
+        }
+        _, err = i.Load(buf)
+        return err
+}
+
+// IndexStream will return an index for a stream.
+// The stream structure will be checked, but
+// data within blocks is not verified.
+// The returned index can either be appended to the end of the stream
+// or stored separately.
+func IndexStream(r io.Reader) ([]byte, error) {
+        var i Index
+        var buf [maxChunkSize]byte
+        var readHeader bool
+        for {
+                _, err := io.ReadFull(r, buf[:4])
+                if err != nil {
+                        if err == io.EOF {
+                                return i.appendTo(nil, i.TotalUncompressed, i.TotalCompressed), nil
+                        }
+                        return nil, err
+                }
+                // Start of this chunk.
+                startChunk := i.TotalCompressed
+                i.TotalCompressed += 4
+
+                chunkType := buf[0]
+                if !readHeader {
+                        if chunkType != chunkTypeStreamIdentifier {
+                                return nil, ErrCorrupt
+                        }
+                        readHeader = true
+                }
+                chunkLen := int(buf[1]) | int(buf[2])<<8 | int(buf[3])<<16
+                if chunkLen < checksumSize {
+                        return nil, ErrCorrupt
+                }
+
+                i.TotalCompressed += int64(chunkLen)
+                _, err = io.ReadFull(r, buf[:chunkLen])
+                if err != nil {
+                        return nil, io.ErrUnexpectedEOF
+                }
+                // The chunk types are specified at
+                // https://github.com/google/snappy/blob/master/framing_format.txt
+                switch chunkType {
+                case chunkTypeCompressedData:
+                        // Section 4.2. Compressed data (chunk type 0x00).
+                        // Skip checksum.
+                        dLen, err := DecodedLen(buf[checksumSize:])
+                        if err != nil {
+                                return nil, err
+                        }
+                        if dLen > maxBlockSize {
+                                return nil, ErrCorrupt
+                        }
+                        if i.estBlockUncomp == 0 {
+                                // Use first block for estimate...
+                                i.estBlockUncomp = int64(dLen)
+                        }
+                        err = i.add(startChunk, i.TotalUncompressed)
+                        if err != nil {
+                                return nil, err
+                        }
+                        i.TotalUncompressed += int64(dLen)
+                        continue
+                case chunkTypeUncompressedData:
+                        n2 := chunkLen - checksumSize
+                        if n2 > maxBlockSize {
+                                return nil, ErrCorrupt
+                        }
+                        if i.estBlockUncomp == 0 {
+                                // Use first block for estimate...
+                                i.estBlockUncomp = int64(n2)
+                        }
+                        err = i.add(startChunk, i.TotalUncompressed)
+                        if err != nil {
+                                return nil, err
+                        }
+                        i.TotalUncompressed += int64(n2)
+                        continue
+                case chunkTypeStreamIdentifier:
+                        // Section 4.1. Stream identifier (chunk type 0xff).
+                        if chunkLen != len(magicBody) {
+                                return nil, ErrCorrupt
+                        }
+
+                        if string(buf[:len(magicBody)]) != magicBody {
+                                if string(buf[:len(magicBody)]) != magicBodySnappy {
+                                        return nil, ErrCorrupt
+                                }
+                        }
+
+                        continue
+                }
+
+                if chunkType <= 0x7f {
+                        // Section 4.5. Reserved unskippable chunks (chunk types 0x02-0x7f).
+                        return nil, ErrUnsupported
+                }
+                if chunkLen > maxChunkSize {
+                        return nil, ErrUnsupported
+                }
+                // Section 4.4 Padding (chunk type 0xfe).
+                // Section 4.6. Reserved skippable chunks (chunk types 0x80-0xfd).
+        }
+}
+
+// JSON returns the index as JSON text.
+func (i *Index) JSON() []byte {
+        type offset struct {
+                CompressedOffset   int64 `json:"compressed"`
+                UncompressedOffset int64 `json:"uncompressed"`
+        }
+        x := struct {
+                TotalUncompressed int64    `json:"total_uncompressed"` // Total Uncompressed size if known. Will be -1 if unknown.
+                TotalCompressed   int64    `json:"total_compressed"`   // Total Compressed size if known. Will be -1 if unknown.
+                Offsets           []offset `json:"offsets"`
+                EstBlockUncomp    int64    `json:"est_block_uncompressed"`
+        }{
+                TotalUncompressed: i.TotalUncompressed,
+                TotalCompressed:   i.TotalCompressed,
+                EstBlockUncomp:    i.estBlockUncomp,
+        }
+        for _, v := range i.info {
+                x.Offsets = append(x.Offsets, offset{CompressedOffset: v.compressedOffset, UncompressedOffset: v.uncompressedOffset})
+        }
+        b, _ := json.MarshalIndent(x, "", "  ")
+        return b
+}
+
+// RemoveIndexHeaders will trim all headers and trailers from a given index.
+// This is expected to save 20 bytes.
+// These can be restored using RestoreIndexHeaders.
+// This removes a layer of security, but is the most compact representation.
+// Returns nil if headers contains errors.
+// The returned slice references the provided slice.
+func RemoveIndexHeaders(b []byte) []byte {
+        const save = 4 + len(S2IndexHeader) + len(S2IndexTrailer) + 4
+        if len(b) <= save {
+                return nil
+        }
+        if b[0] != ChunkTypeIndex {
+                return nil
+        }
+        chunkLen := int(b[1]) | int(b[2])<<8 | int(b[3])<<16
+        b = b[4:]
+
+        // Validate we have enough...
+        if len(b) < chunkLen {
+                return nil
+        }
+        b = b[:chunkLen]
+
+        if !bytes.Equal(b[:len(S2IndexHeader)], []byte(S2IndexHeader)) {
+                return nil
+        }
+        b = b[len(S2IndexHeader):]
+        if !bytes.HasSuffix(b, []byte(S2IndexTrailer)) {
+                return nil
+        }
+        b = bytes.TrimSuffix(b, []byte(S2IndexTrailer))
+
+        if len(b) < 4 {
+                return nil
+        }
+        return b[:len(b)-4]
+}
+
+// RestoreIndexHeaders will index restore headers removed by RemoveIndexHeaders.
+// No error checking is performed on the input.
+// If a 0 length slice is sent, it is returned without modification.
+func RestoreIndexHeaders(in []byte) []byte {
+        if len(in) == 0 {
+                return in
+        }
+        b := make([]byte, 0, 4+len(S2IndexHeader)+len(in)+len(S2IndexTrailer)+4)
+        b = append(b, ChunkTypeIndex, 0, 0, 0)
+        b = append(b, []byte(S2IndexHeader)...)
+        b = append(b, in...)
+
+        var tmp [4]byte
+        binary.LittleEndian.PutUint32(tmp[:], uint32(len(b)+4+len(S2IndexTrailer)))
+        b = append(b, tmp[:4]...)
+        // Trailer
+        b = append(b, []byte(S2IndexTrailer)...)
+
+        chunkLen := len(b) - skippableFrameHeader
+        b[1] = uint8(chunkLen >> 0)
+        b[2] = uint8(chunkLen >> 8)
+        b[3] = uint8(chunkLen >> 16)
+        return b
+}
diff --git a/vendor/github.com/klauspost/compress/s2/lz4convert.go b/vendor/github.com/klauspost/compress/s2/lz4convert.go
new file mode 100644
index 0000000..46ed908
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/lz4convert.go
@@ -0,0 +1,585 @@
+// Copyright (c) 2022 Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s2
+
+import (
+        "encoding/binary"
+        "errors"
+        "fmt"
+)
+
+// LZ4Converter provides conversion from LZ4 blocks as defined here:
+// https://github.com/lz4/lz4/blob/dev/doc/lz4_Block_format.md
+type LZ4Converter struct {
+}
+
+// ErrDstTooSmall is returned when provided destination is too small.
+var ErrDstTooSmall = errors.New("s2: destination too small")
+
+// ConvertBlock will convert an LZ4 block and append it as an S2
+// block without block length to dst.
+// The uncompressed size is returned as well.
+// dst must have capacity to contain the entire compressed block.
+func (l *LZ4Converter) ConvertBlock(dst, src []byte) ([]byte, int, error) {
+        if len(src) == 0 {
+                return dst, 0, nil
+        }
+        const debug = false
+        const inline = true
+        const lz4MinMatch = 4
+
+        s, d := 0, len(dst)
+        dst = dst[:cap(dst)]
+        if !debug && hasAmd64Asm {
+                res, sz := cvtLZ4BlockAsm(dst[d:], src)
+                if res < 0 {
+                        const (
+                                errCorrupt     = -1
+                                errDstTooSmall = -2
+                        )
+                        switch res {
+                        case errCorrupt:
+                                return nil, 0, ErrCorrupt
+                        case errDstTooSmall:
+                                return nil, 0, ErrDstTooSmall
+                        default:
+                                return nil, 0, fmt.Errorf("unexpected result: %d", res)
+                        }
+                }
+                if d+sz > len(dst) {
+                        return nil, 0, ErrDstTooSmall
+                }
+                return dst[:d+sz], res, nil
+        }
+
+        dLimit := len(dst) - 10
+        var lastOffset uint16
+        var uncompressed int
+        if debug {
+                fmt.Printf("convert block start: len(src): %d, len(dst):%d \n", len(src), len(dst))
+        }
+
+        for {
+                if s >= len(src) {
+                        return dst[:d], 0, ErrCorrupt
+                }
+                // Read literal info
+                token := src[s]
+                ll := int(token >> 4)
+                ml := int(lz4MinMatch + (token & 0xf))
+
+                // If upper nibble is 15, literal length is extended
+                if token >= 0xf0 {
+                        for {
+                                s++
+                                if s >= len(src) {
+                                        if debug {
+                                                fmt.Printf("error reading ll: s (%d) >= len(src) (%d)\n", s, len(src))
+                                        }
+                                        return dst[:d], 0, ErrCorrupt
+                                }
+                                val := src[s]
+                                ll += int(val)
+                                if val != 255 {
+                                        break
+                                }
+                        }
+                }
+                // Skip past token
+                if s+ll >= len(src) {
+                        if debug {
+                                fmt.Printf("error literals: s+ll (%d+%d) >= len(src) (%d)\n", s, ll, len(src))
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+                s++
+                if ll > 0 {
+                        if d+ll > dLimit {
+                                return nil, 0, ErrDstTooSmall
+                        }
+                        if debug {
+                                fmt.Printf("emit %d literals\n", ll)
+                        }
+                        d += emitLiteralGo(dst[d:], src[s:s+ll])
+                        s += ll
+                        uncompressed += ll
+                }
+
+                // Check if we are done...
+                if s == len(src) && ml == lz4MinMatch {
+                        break
+                }
+                // 2 byte offset
+                if s >= len(src)-2 {
+                        if debug {
+                                fmt.Printf("s (%d) >= len(src)-2 (%d)", s, len(src)-2)
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+                offset := binary.LittleEndian.Uint16(src[s:])
+                s += 2
+                if offset == 0 {
+                        if debug {
+                                fmt.Printf("error: offset 0, ml: %d, len(src)-s: %d\n", ml, len(src)-s)
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+                if int(offset) > uncompressed {
+                        if debug {
+                                fmt.Printf("error: offset (%d)> uncompressed (%d)\n", offset, uncompressed)
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+
+                if ml == lz4MinMatch+15 {
+                        for {
+                                if s >= len(src) {
+                                        if debug {
+                                                fmt.Printf("error reading ml: s (%d) >= len(src) (%d)\n", s, len(src))
+                                        }
+                                        return nil, 0, ErrCorrupt
+                                }
+                                val := src[s]
+                                s++
+                                ml += int(val)
+                                if val != 255 {
+                                        if s >= len(src) {
+                                                if debug {
+                                                        fmt.Printf("error reading ml: s (%d) >= len(src) (%d)\n", s, len(src))
+                                                }
+                                                return nil, 0, ErrCorrupt
+                                        }
+                                        break
+                                }
+                        }
+                }
+                if offset == lastOffset {
+                        if debug {
+                                fmt.Printf("emit repeat, length: %d, offset: %d\n", ml, offset)
+                        }
+                        if !inline {
+                                d += emitRepeat16(dst[d:], offset, ml)
+                        } else {
+                                length := ml
+                                dst := dst[d:]
+                                for len(dst) > 5 {
+                                        // Repeat offset, make length cheaper
+                                        length -= 4
+                                        if length <= 4 {
+                                                dst[0] = uint8(length)<<2 | tagCopy1
+                                                dst[1] = 0
+                                                d += 2
+                                                break
+                                        }
+                                        if length < 8 && offset < 2048 {
+                                                // Encode WITH offset
+                                                dst[1] = uint8(offset)
+                                                dst[0] = uint8(offset>>8)<<5 | uint8(length)<<2 | tagCopy1
+                                                d += 2
+                                                break
+                                        }
+                                        if length < (1<<8)+4 {
+                                                length -= 4
+                                                dst[2] = uint8(length)
+                                                dst[1] = 0
+                                                dst[0] = 5<<2 | tagCopy1
+                                                d += 3
+                                                break
+                                        }
+                                        if length < (1<<16)+(1<<8) {
+                                                length -= 1 << 8
+                                                dst[3] = uint8(length >> 8)
+                                                dst[2] = uint8(length >> 0)
+                                                dst[1] = 0
+                                                dst[0] = 6<<2 | tagCopy1
+                                                d += 4
+                                                break
+                                        }
+                                        const maxRepeat = (1 << 24) - 1
+                                        length -= 1 << 16
+                                        left := 0
+                                        if length > maxRepeat {
+                                                left = length - maxRepeat + 4
+                                                length = maxRepeat - 4
+                                        }
+                                        dst[4] = uint8(length >> 16)
+                                        dst[3] = uint8(length >> 8)
+                                        dst[2] = uint8(length >> 0)
+                                        dst[1] = 0
+                                        dst[0] = 7<<2 | tagCopy1
+                                        if left > 0 {
+                                                d += 5 + emitRepeat16(dst[5:], offset, left)
+                                                break
+                                        }
+                                        d += 5
+                                        break
+                                }
+                        }
+                } else {
+                        if debug {
+                                fmt.Printf("emit copy, length: %d, offset: %d\n", ml, offset)
+                        }
+                        if !inline {
+                                d += emitCopy16(dst[d:], offset, ml)
+                        } else {
+                                length := ml
+                                dst := dst[d:]
+                                for len(dst) > 5 {
+                                        // Offset no more than 2 bytes.
+                                        if length > 64 {
+                                                off := 3
+                                                if offset < 2048 {
+                                                        // emit 8 bytes as tagCopy1, rest as repeats.
+                                                        dst[1] = uint8(offset)
+                                                        dst[0] = uint8(offset>>8)<<5 | uint8(8-4)<<2 | tagCopy1
+                                                        length -= 8
+                                                        off = 2
+                                                } else {
+                                                        // Emit a length 60 copy, encoded as 3 bytes.
+                                                        // Emit remaining as repeat value (minimum 4 bytes).
+                                                        dst[2] = uint8(offset >> 8)
+                                                        dst[1] = uint8(offset)
+                                                        dst[0] = 59<<2 | tagCopy2
+                                                        length -= 60
+                                                }
+                                                // Emit remaining as repeats, at least 4 bytes remain.
+                                                d += off + emitRepeat16(dst[off:], offset, length)
+                                                break
+                                        }
+                                        if length >= 12 || offset >= 2048 {
+                                                // Emit the remaining copy, encoded as 3 bytes.
+                                                dst[2] = uint8(offset >> 8)
+                                                dst[1] = uint8(offset)
+                                                dst[0] = uint8(length-1)<<2 | tagCopy2
+                                                d += 3
+                                                break
+                                        }
+                                        // Emit the remaining copy, encoded as 2 bytes.
+                                        dst[1] = uint8(offset)
+                                        dst[0] = uint8(offset>>8)<<5 | uint8(length-4)<<2 | tagCopy1
+                                        d += 2
+                                        break
+                                }
+                        }
+                        lastOffset = offset
+                }
+                uncompressed += ml
+                if d > dLimit {
+                        return nil, 0, ErrDstTooSmall
+                }
+        }
+
+        return dst[:d], uncompressed, nil
+}
+
+// ConvertBlockSnappy will convert an LZ4 block and append it
+// as a Snappy block without block length to dst.
+// The uncompressed size is returned as well.
+// dst must have capacity to contain the entire compressed block.
+func (l *LZ4Converter) ConvertBlockSnappy(dst, src []byte) ([]byte, int, error) {
+        if len(src) == 0 {
+                return dst, 0, nil
+        }
+        const debug = false
+        const lz4MinMatch = 4
+
+        s, d := 0, len(dst)
+        dst = dst[:cap(dst)]
+        // Use assembly when possible
+        if !debug && hasAmd64Asm {
+                res, sz := cvtLZ4BlockSnappyAsm(dst[d:], src)
+                if res < 0 {
+                        const (
+                                errCorrupt     = -1
+                                errDstTooSmall = -2
+                        )
+                        switch res {
+                        case errCorrupt:
+                                return nil, 0, ErrCorrupt
+                        case errDstTooSmall:
+                                return nil, 0, ErrDstTooSmall
+                        default:
+                                return nil, 0, fmt.Errorf("unexpected result: %d", res)
+                        }
+                }
+                if d+sz > len(dst) {
+                        return nil, 0, ErrDstTooSmall
+                }
+                return dst[:d+sz], res, nil
+        }
+
+        dLimit := len(dst) - 10
+        var uncompressed int
+        if debug {
+                fmt.Printf("convert block start: len(src): %d, len(dst):%d \n", len(src), len(dst))
+        }
+
+        for {
+                if s >= len(src) {
+                        return nil, 0, ErrCorrupt
+                }
+                // Read literal info
+                token := src[s]
+                ll := int(token >> 4)
+                ml := int(lz4MinMatch + (token & 0xf))
+
+                // If upper nibble is 15, literal length is extended
+                if token >= 0xf0 {
+                        for {
+                                s++
+                                if s >= len(src) {
+                                        if debug {
+                                                fmt.Printf("error reading ll: s (%d) >= len(src) (%d)\n", s, len(src))
+                                        }
+                                        return nil, 0, ErrCorrupt
+                                }
+                                val := src[s]
+                                ll += int(val)
+                                if val != 255 {
+                                        break
+                                }
+                        }
+                }
+                // Skip past token
+                if s+ll >= len(src) {
+                        if debug {
+                                fmt.Printf("error literals: s+ll (%d+%d) >= len(src) (%d)\n", s, ll, len(src))
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+                s++
+                if ll > 0 {
+                        if d+ll > dLimit {
+                                return nil, 0, ErrDstTooSmall
+                        }
+                        if debug {
+                                fmt.Printf("emit %d literals\n", ll)
+                        }
+                        d += emitLiteralGo(dst[d:], src[s:s+ll])
+                        s += ll
+                        uncompressed += ll
+                }
+
+                // Check if we are done...
+                if s == len(src) && ml == lz4MinMatch {
+                        break
+                }
+                // 2 byte offset
+                if s >= len(src)-2 {
+                        if debug {
+                                fmt.Printf("s (%d) >= len(src)-2 (%d)", s, len(src)-2)
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+                offset := binary.LittleEndian.Uint16(src[s:])
+                s += 2
+                if offset == 0 {
+                        if debug {
+                                fmt.Printf("error: offset 0, ml: %d, len(src)-s: %d\n", ml, len(src)-s)
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+                if int(offset) > uncompressed {
+                        if debug {
+                                fmt.Printf("error: offset (%d)> uncompressed (%d)\n", offset, uncompressed)
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+
+                if ml == lz4MinMatch+15 {
+                        for {
+                                if s >= len(src) {
+                                        if debug {
+                                                fmt.Printf("error reading ml: s (%d) >= len(src) (%d)\n", s, len(src))
+                                        }
+                                        return nil, 0, ErrCorrupt
+                                }
+                                val := src[s]
+                                s++
+                                ml += int(val)
+                                if val != 255 {
+                                        if s >= len(src) {
+                                                if debug {
+                                                        fmt.Printf("error reading ml: s (%d) >= len(src) (%d)\n", s, len(src))
+                                                }
+                                                return nil, 0, ErrCorrupt
+                                        }
+                                        break
+                                }
+                        }
+                }
+                if debug {
+                        fmt.Printf("emit copy, length: %d, offset: %d\n", ml, offset)
+                }
+                length := ml
+                // d += emitCopyNoRepeat(dst[d:], int(offset), ml)
+                for length > 0 {
+                        if d >= dLimit {
+                                return nil, 0, ErrDstTooSmall
+                        }
+
+                        // Offset no more than 2 bytes.
+                        if length > 64 {
+                                // Emit a length 64 copy, encoded as 3 bytes.
+                                dst[d+2] = uint8(offset >> 8)
+                                dst[d+1] = uint8(offset)
+                                dst[d+0] = 63<<2 | tagCopy2
+                                length -= 64
+                                d += 3
+                                continue
+                        }
+                        if length >= 12 || offset >= 2048 || length < 4 {
+                                // Emit the remaining copy, encoded as 3 bytes.
+                                dst[d+2] = uint8(offset >> 8)
+                                dst[d+1] = uint8(offset)
+                                dst[d+0] = uint8(length-1)<<2 | tagCopy2
+                                d += 3
+                                break
+                        }
+                        // Emit the remaining copy, encoded as 2 bytes.
+                        dst[d+1] = uint8(offset)
+                        dst[d+0] = uint8(offset>>8)<<5 | uint8(length-4)<<2 | tagCopy1
+                        d += 2
+                        break
+                }
+                uncompressed += ml
+                if d > dLimit {
+                        return nil, 0, ErrDstTooSmall
+                }
+        }
+
+        return dst[:d], uncompressed, nil
+}
+
+// emitRepeat writes a repeat chunk and returns the number of bytes written.
+// Length must be at least 4 and < 1<<24
+func emitRepeat16(dst []byte, offset uint16, length int) int {
+        // Repeat offset, make length cheaper
+        length -= 4
+        if length <= 4 {
+                dst[0] = uint8(length)<<2 | tagCopy1
+                dst[1] = 0
+                return 2
+        }
+        if length < 8 && offset < 2048 {
+                // Encode WITH offset
+                dst[1] = uint8(offset)
+                dst[0] = uint8(offset>>8)<<5 | uint8(length)<<2 | tagCopy1
+                return 2
+        }
+        if length < (1<<8)+4 {
+                length -= 4
+                dst[2] = uint8(length)
+                dst[1] = 0
+                dst[0] = 5<<2 | tagCopy1
+                return 3
+        }
+        if length < (1<<16)+(1<<8) {
+                length -= 1 << 8
+                dst[3] = uint8(length >> 8)
+                dst[2] = uint8(length >> 0)
+                dst[1] = 0
+                dst[0] = 6<<2 | tagCopy1
+                return 4
+        }
+        const maxRepeat = (1 << 24) - 1
+        length -= 1 << 16
+        left := 0
+        if length > maxRepeat {
+                left = length - maxRepeat + 4
+                length = maxRepeat - 4
+        }
+        dst[4] = uint8(length >> 16)
+        dst[3] = uint8(length >> 8)
+        dst[2] = uint8(length >> 0)
+        dst[1] = 0
+        dst[0] = 7<<2 | tagCopy1
+        if left > 0 {
+                return 5 + emitRepeat16(dst[5:], offset, left)
+        }
+        return 5
+}
+
+// emitCopy writes a copy chunk and returns the number of bytes written.
+//
+// It assumes that:
+//
+//      dst is long enough to hold the encoded bytes
+//      1 <= offset && offset <= math.MaxUint16
+//      4 <= length && length <= math.MaxUint32
+func emitCopy16(dst []byte, offset uint16, length int) int {
+        // Offset no more than 2 bytes.
+        if length > 64 {
+                off := 3
+                if offset < 2048 {
+                        // emit 8 bytes as tagCopy1, rest as repeats.
+                        dst[1] = uint8(offset)
+                        dst[0] = uint8(offset>>8)<<5 | uint8(8-4)<<2 | tagCopy1
+                        length -= 8
+                        off = 2
+                } else {
+                        // Emit a length 60 copy, encoded as 3 bytes.
+                        // Emit remaining as repeat value (minimum 4 bytes).
+                        dst[2] = uint8(offset >> 8)
+                        dst[1] = uint8(offset)
+                        dst[0] = 59<<2 | tagCopy2
+                        length -= 60
+                }
+                // Emit remaining as repeats, at least 4 bytes remain.
+                return off + emitRepeat16(dst[off:], offset, length)
+        }
+        if length >= 12 || offset >= 2048 {
+                // Emit the remaining copy, encoded as 3 bytes.
+                dst[2] = uint8(offset >> 8)
+                dst[1] = uint8(offset)
+                dst[0] = uint8(length-1)<<2 | tagCopy2
+                return 3
+        }
+        // Emit the remaining copy, encoded as 2 bytes.
+        dst[1] = uint8(offset)
+        dst[0] = uint8(offset>>8)<<5 | uint8(length-4)<<2 | tagCopy1
+        return 2
+}
+
+// emitLiteral writes a literal chunk and returns the number of bytes written.
+//
+// It assumes that:
+//
+//      dst is long enough to hold the encoded bytes
+//      0 <= len(lit) && len(lit) <= math.MaxUint32
+func emitLiteralGo(dst, lit []byte) int {
+        if len(lit) == 0 {
+                return 0
+        }
+        i, n := 0, uint(len(lit)-1)
+        switch {
+        case n < 60:
+                dst[0] = uint8(n)<<2 | tagLiteral
+                i = 1
+        case n < 1<<8:
+                dst[1] = uint8(n)
+                dst[0] = 60<<2 | tagLiteral
+                i = 2
+        case n < 1<<16:
+                dst[2] = uint8(n >> 8)
+                dst[1] = uint8(n)
+                dst[0] = 61<<2 | tagLiteral
+                i = 3
+        case n < 1<<24:
+                dst[3] = uint8(n >> 16)
+                dst[2] = uint8(n >> 8)
+                dst[1] = uint8(n)
+                dst[0] = 62<<2 | tagLiteral
+                i = 4
+        default:
+                dst[4] = uint8(n >> 24)
+                dst[3] = uint8(n >> 16)
+                dst[2] = uint8(n >> 8)
+                dst[1] = uint8(n)
+                dst[0] = 63<<2 | tagLiteral
+                i = 5
+        }
+        return i + copy(dst[i:], lit)
+}
diff --git a/vendor/github.com/klauspost/compress/s2/lz4sconvert.go b/vendor/github.com/klauspost/compress/s2/lz4sconvert.go
new file mode 100644
index 0000000..000f397
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/lz4sconvert.go
@@ -0,0 +1,467 @@
+// Copyright (c) 2022 Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s2
+
+import (
+        "encoding/binary"
+        "fmt"
+)
+
+// LZ4sConverter provides conversion from LZ4s.
+// (Intel modified LZ4 Blocks)
+// https://cdrdv2-public.intel.com/743912/743912-qat-programmers-guide-v2.0.pdf
+// LZ4s is a variant of LZ4 block format. LZ4s should be considered as an intermediate compressed block format.
+// The LZ4s format is selected when the application sets the compType to CPA_DC_LZ4S in CpaDcSessionSetupData.
+// The LZ4s block returned by the Intel® QAT hardware can be used by an external
+// software post-processing to generate other compressed data formats.
+// The following table lists the differences between LZ4 and LZ4s block format. LZ4s block format uses
+// the same high-level formatting as LZ4 block format with the following encoding changes:
+// For Min Match of 4 bytes, Copy length value 1-15 means length 4-18 with 18 bytes adding an extra byte.
+// ONLY "Min match of 4 bytes" is supported.
+type LZ4sConverter struct {
+}
+
+// ConvertBlock will convert an LZ4s block and append it as an S2
+// block without block length to dst.
+// The uncompressed size is returned as well.
+// dst must have capacity to contain the entire compressed block.
+func (l *LZ4sConverter) ConvertBlock(dst, src []byte) ([]byte, int, error) {
+        if len(src) == 0 {
+                return dst, 0, nil
+        }
+        const debug = false
+        const inline = true
+        const lz4MinMatch = 3
+
+        s, d := 0, len(dst)
+        dst = dst[:cap(dst)]
+        if !debug && hasAmd64Asm {
+                res, sz := cvtLZ4sBlockAsm(dst[d:], src)
+                if res < 0 {
+                        const (
+                                errCorrupt     = -1
+                                errDstTooSmall = -2
+                        )
+                        switch res {
+                        case errCorrupt:
+                                return nil, 0, ErrCorrupt
+                        case errDstTooSmall:
+                                return nil, 0, ErrDstTooSmall
+                        default:
+                                return nil, 0, fmt.Errorf("unexpected result: %d", res)
+                        }
+                }
+                if d+sz > len(dst) {
+                        return nil, 0, ErrDstTooSmall
+                }
+                return dst[:d+sz], res, nil
+        }
+
+        dLimit := len(dst) - 10
+        var lastOffset uint16
+        var uncompressed int
+        if debug {
+                fmt.Printf("convert block start: len(src): %d, len(dst):%d \n", len(src), len(dst))
+        }
+
+        for {
+                if s >= len(src) {
+                        return dst[:d], 0, ErrCorrupt
+                }
+                // Read literal info
+                token := src[s]
+                ll := int(token >> 4)
+                ml := int(lz4MinMatch + (token & 0xf))
+
+                // If upper nibble is 15, literal length is extended
+                if token >= 0xf0 {
+                        for {
+                                s++
+                                if s >= len(src) {
+                                        if debug {
+                                                fmt.Printf("error reading ll: s (%d) >= len(src) (%d)\n", s, len(src))
+                                        }
+                                        return dst[:d], 0, ErrCorrupt
+                                }
+                                val := src[s]
+                                ll += int(val)
+                                if val != 255 {
+                                        break
+                                }
+                        }
+                }
+                // Skip past token
+                if s+ll >= len(src) {
+                        if debug {
+                                fmt.Printf("error literals: s+ll (%d+%d) >= len(src) (%d)\n", s, ll, len(src))
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+                s++
+                if ll > 0 {
+                        if d+ll > dLimit {
+                                return nil, 0, ErrDstTooSmall
+                        }
+                        if debug {
+                                fmt.Printf("emit %d literals\n", ll)
+                        }
+                        d += emitLiteralGo(dst[d:], src[s:s+ll])
+                        s += ll
+                        uncompressed += ll
+                }
+
+                // Check if we are done...
+                if ml == lz4MinMatch {
+                        if s == len(src) {
+                                break
+                        }
+                        // 0 bytes.
+                        continue
+                }
+                // 2 byte offset
+                if s >= len(src)-2 {
+                        if debug {
+                                fmt.Printf("s (%d) >= len(src)-2 (%d)", s, len(src)-2)
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+                offset := binary.LittleEndian.Uint16(src[s:])
+                s += 2
+                if offset == 0 {
+                        if debug {
+                                fmt.Printf("error: offset 0, ml: %d, len(src)-s: %d\n", ml, len(src)-s)
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+                if int(offset) > uncompressed {
+                        if debug {
+                                fmt.Printf("error: offset (%d)> uncompressed (%d)\n", offset, uncompressed)
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+
+                if ml == lz4MinMatch+15 {
+                        for {
+                                if s >= len(src) {
+                                        if debug {
+                                                fmt.Printf("error reading ml: s (%d) >= len(src) (%d)\n", s, len(src))
+                                        }
+                                        return nil, 0, ErrCorrupt
+                                }
+                                val := src[s]
+                                s++
+                                ml += int(val)
+                                if val != 255 {
+                                        if s >= len(src) {
+                                                if debug {
+                                                        fmt.Printf("error reading ml: s (%d) >= len(src) (%d)\n", s, len(src))
+                                                }
+                                                return nil, 0, ErrCorrupt
+                                        }
+                                        break
+                                }
+                        }
+                }
+                if offset == lastOffset {
+                        if debug {
+                                fmt.Printf("emit repeat, length: %d, offset: %d\n", ml, offset)
+                        }
+                        if !inline {
+                                d += emitRepeat16(dst[d:], offset, ml)
+                        } else {
+                                length := ml
+                                dst := dst[d:]
+                                for len(dst) > 5 {
+                                        // Repeat offset, make length cheaper
+                                        length -= 4
+                                        if length <= 4 {
+                                                dst[0] = uint8(length)<<2 | tagCopy1
+                                                dst[1] = 0
+                                                d += 2
+                                                break
+                                        }
+                                        if length < 8 && offset < 2048 {
+                                                // Encode WITH offset
+                                                dst[1] = uint8(offset)
+                                                dst[0] = uint8(offset>>8)<<5 | uint8(length)<<2 | tagCopy1
+                                                d += 2
+                                                break
+                                        }
+                                        if length < (1<<8)+4 {
+                                                length -= 4
+                                                dst[2] = uint8(length)
+                                                dst[1] = 0
+                                                dst[0] = 5<<2 | tagCopy1
+                                                d += 3
+                                                break
+                                        }
+                                        if length < (1<<16)+(1<<8) {
+                                                length -= 1 << 8
+                                                dst[3] = uint8(length >> 8)
+                                                dst[2] = uint8(length >> 0)
+                                                dst[1] = 0
+                                                dst[0] = 6<<2 | tagCopy1
+                                                d += 4
+                                                break
+                                        }
+                                        const maxRepeat = (1 << 24) - 1
+                                        length -= 1 << 16
+                                        left := 0
+                                        if length > maxRepeat {
+                                                left = length - maxRepeat + 4
+                                                length = maxRepeat - 4
+                                        }
+                                        dst[4] = uint8(length >> 16)
+                                        dst[3] = uint8(length >> 8)
+                                        dst[2] = uint8(length >> 0)
+                                        dst[1] = 0
+                                        dst[0] = 7<<2 | tagCopy1
+                                        if left > 0 {
+                                                d += 5 + emitRepeat16(dst[5:], offset, left)
+                                                break
+                                        }
+                                        d += 5
+                                        break
+                                }
+                        }
+                } else {
+                        if debug {
+                                fmt.Printf("emit copy, length: %d, offset: %d\n", ml, offset)
+                        }
+                        if !inline {
+                                d += emitCopy16(dst[d:], offset, ml)
+                        } else {
+                                length := ml
+                                dst := dst[d:]
+                                for len(dst) > 5 {
+                                        // Offset no more than 2 bytes.
+                                        if length > 64 {
+                                                off := 3
+                                                if offset < 2048 {
+                                                        // emit 8 bytes as tagCopy1, rest as repeats.
+                                                        dst[1] = uint8(offset)
+                                                        dst[0] = uint8(offset>>8)<<5 | uint8(8-4)<<2 | tagCopy1
+                                                        length -= 8
+                                                        off = 2
+                                                } else {
+                                                        // Emit a length 60 copy, encoded as 3 bytes.
+                                                        // Emit remaining as repeat value (minimum 4 bytes).
+                                                        dst[2] = uint8(offset >> 8)
+                                                        dst[1] = uint8(offset)
+                                                        dst[0] = 59<<2 | tagCopy2
+                                                        length -= 60
+                                                }
+                                                // Emit remaining as repeats, at least 4 bytes remain.
+                                                d += off + emitRepeat16(dst[off:], offset, length)
+                                                break
+                                        }
+                                        if length >= 12 || offset >= 2048 {
+                                                // Emit the remaining copy, encoded as 3 bytes.
+                                                dst[2] = uint8(offset >> 8)
+                                                dst[1] = uint8(offset)
+                                                dst[0] = uint8(length-1)<<2 | tagCopy2
+                                                d += 3
+                                                break
+                                        }
+                                        // Emit the remaining copy, encoded as 2 bytes.
+                                        dst[1] = uint8(offset)
+                                        dst[0] = uint8(offset>>8)<<5 | uint8(length-4)<<2 | tagCopy1
+                                        d += 2
+                                        break
+                                }
+                        }
+                        lastOffset = offset
+                }
+                uncompressed += ml
+                if d > dLimit {
+                        return nil, 0, ErrDstTooSmall
+                }
+        }
+
+        return dst[:d], uncompressed, nil
+}
+
+// ConvertBlockSnappy will convert an LZ4s block and append it
+// as a Snappy block without block length to dst.
+// The uncompressed size is returned as well.
+// dst must have capacity to contain the entire compressed block.
+func (l *LZ4sConverter) ConvertBlockSnappy(dst, src []byte) ([]byte, int, error) {
+        if len(src) == 0 {
+                return dst, 0, nil
+        }
+        const debug = false
+        const lz4MinMatch = 3
+
+        s, d := 0, len(dst)
+        dst = dst[:cap(dst)]
+        // Use assembly when possible
+        if !debug && hasAmd64Asm {
+                res, sz := cvtLZ4sBlockSnappyAsm(dst[d:], src)
+                if res < 0 {
+                        const (
+                                errCorrupt     = -1
+                                errDstTooSmall = -2
+                        )
+                        switch res {
+                        case errCorrupt:
+                                return nil, 0, ErrCorrupt
+                        case errDstTooSmall:
+                                return nil, 0, ErrDstTooSmall
+                        default:
+                                return nil, 0, fmt.Errorf("unexpected result: %d", res)
+                        }
+                }
+                if d+sz > len(dst) {
+                        return nil, 0, ErrDstTooSmall
+                }
+                return dst[:d+sz], res, nil
+        }
+
+        dLimit := len(dst) - 10
+        var uncompressed int
+        if debug {
+                fmt.Printf("convert block start: len(src): %d, len(dst):%d \n", len(src), len(dst))
+        }
+
+        for {
+                if s >= len(src) {
+                        return nil, 0, ErrCorrupt
+                }
+                // Read literal info
+                token := src[s]
+                ll := int(token >> 4)
+                ml := int(lz4MinMatch + (token & 0xf))
+
+                // If upper nibble is 15, literal length is extended
+                if token >= 0xf0 {
+                        for {
+                                s++
+                                if s >= len(src) {
+                                        if debug {
+                                                fmt.Printf("error reading ll: s (%d) >= len(src) (%d)\n", s, len(src))
+                                        }
+                                        return nil, 0, ErrCorrupt
+                                }
+                                val := src[s]
+                                ll += int(val)
+                                if val != 255 {
+                                        break
+                                }
+                        }
+                }
+                // Skip past token
+                if s+ll >= len(src) {
+                        if debug {
+                                fmt.Printf("error literals: s+ll (%d+%d) >= len(src) (%d)\n", s, ll, len(src))
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+                s++
+                if ll > 0 {
+                        if d+ll > dLimit {
+                                return nil, 0, ErrDstTooSmall
+                        }
+                        if debug {
+                                fmt.Printf("emit %d literals\n", ll)
+                        }
+                        d += emitLiteralGo(dst[d:], src[s:s+ll])
+                        s += ll
+                        uncompressed += ll
+                }
+
+                // Check if we are done...
+                if ml == lz4MinMatch {
+                        if s == len(src) {
+                                break
+                        }
+                        // 0 bytes.
+                        continue
+                }
+                // 2 byte offset
+                if s >= len(src)-2 {
+                        if debug {
+                                fmt.Printf("s (%d) >= len(src)-2 (%d)", s, len(src)-2)
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+                offset := binary.LittleEndian.Uint16(src[s:])
+                s += 2
+                if offset == 0 {
+                        if debug {
+                                fmt.Printf("error: offset 0, ml: %d, len(src)-s: %d\n", ml, len(src)-s)
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+                if int(offset) > uncompressed {
+                        if debug {
+                                fmt.Printf("error: offset (%d)> uncompressed (%d)\n", offset, uncompressed)
+                        }
+                        return nil, 0, ErrCorrupt
+                }
+
+                if ml == lz4MinMatch+15 {
+                        for {
+                                if s >= len(src) {
+                                        if debug {
+                                                fmt.Printf("error reading ml: s (%d) >= len(src) (%d)\n", s, len(src))
+                                        }
+                                        return nil, 0, ErrCorrupt
+                                }
+                                val := src[s]
+                                s++
+                                ml += int(val)
+                                if val != 255 {
+                                        if s >= len(src) {
+                                                if debug {
+                                                        fmt.Printf("error reading ml: s (%d) >= len(src) (%d)\n", s, len(src))
+                                                }
+                                                return nil, 0, ErrCorrupt
+                                        }
+                                        break
+                                }
+                        }
+                }
+                if debug {
+                        fmt.Printf("emit copy, length: %d, offset: %d\n", ml, offset)
+                }
+                length := ml
+                // d += emitCopyNoRepeat(dst[d:], int(offset), ml)
+                for length > 0 {
+                        if d >= dLimit {
+                                return nil, 0, ErrDstTooSmall
+                        }
+
+                        // Offset no more than 2 bytes.
+                        if length > 64 {
+                                // Emit a length 64 copy, encoded as 3 bytes.
+                                dst[d+2] = uint8(offset >> 8)
+                                dst[d+1] = uint8(offset)
+                                dst[d+0] = 63<<2 | tagCopy2
+                                length -= 64
+                                d += 3
+                                continue
+                        }
+                        if length >= 12 || offset >= 2048 || length < 4 {
+                                // Emit the remaining copy, encoded as 3 bytes.
+                                dst[d+2] = uint8(offset >> 8)
+                                dst[d+1] = uint8(offset)
+                                dst[d+0] = uint8(length-1)<<2 | tagCopy2
+                                d += 3
+                                break
+                        }
+                        // Emit the remaining copy, encoded as 2 bytes.
+                        dst[d+1] = uint8(offset)
+                        dst[d+0] = uint8(offset>>8)<<5 | uint8(length-4)<<2 | tagCopy1
+                        d += 2
+                        break
+                }
+                uncompressed += ml
+                if d > dLimit {
+                        return nil, 0, ErrDstTooSmall
+                }
+        }
+
+        return dst[:d], uncompressed, nil
+}
diff --git a/vendor/github.com/klauspost/compress/s2/reader.go b/vendor/github.com/klauspost/compress/s2/reader.go
new file mode 100644
index 0000000..2f01a39
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/reader.go
@@ -0,0 +1,1062 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Copyright (c) 2019+ Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s2
+
+import (
+        "errors"
+        "fmt"
+        "io"
+        "io/ioutil"
+        "math"
+        "runtime"
+        "sync"
+)
+
+// ErrCantSeek is returned if the stream cannot be seeked.
+type ErrCantSeek struct {
+        Reason string
+}
+
+// Error returns the error as string.
+func (e ErrCantSeek) Error() string {
+        return fmt.Sprintf("s2: Can't seek because %s", e.Reason)
+}
+
+// NewReader returns a new Reader that decompresses from r, using the framing
+// format described at
+// https://github.com/google/snappy/blob/master/framing_format.txt with S2 changes.
+func NewReader(r io.Reader, opts ...ReaderOption) *Reader {
+        nr := Reader{
+                r:        r,
+                maxBlock: maxBlockSize,
+        }
+        for _, opt := range opts {
+                if err := opt(&nr); err != nil {
+                        nr.err = err
+                        return &nr
+                }
+        }
+        nr.maxBufSize = MaxEncodedLen(nr.maxBlock) + checksumSize
+        if nr.lazyBuf > 0 {
+                nr.buf = make([]byte, MaxEncodedLen(nr.lazyBuf)+checksumSize)
+        } else {
+                nr.buf = make([]byte, MaxEncodedLen(defaultBlockSize)+checksumSize)
+        }
+        nr.readHeader = nr.ignoreStreamID
+        nr.paramsOK = true
+        return &nr
+}
+
+// ReaderOption is an option for creating a decoder.
+type ReaderOption func(*Reader) error
+
+// ReaderMaxBlockSize allows to control allocations if the stream
+// has been compressed with a smaller WriterBlockSize, or with the default 1MB.
+// Blocks must be this size or smaller to decompress,
+// otherwise the decoder will return ErrUnsupported.
+//
+// For streams compressed with Snappy this can safely be set to 64KB (64 << 10).
+//
+// Default is the maximum limit of 4MB.
+func ReaderMaxBlockSize(blockSize int) ReaderOption {
+        return func(r *Reader) error {
+                if blockSize > maxBlockSize || blockSize <= 0 {
+                        return errors.New("s2: block size too large. Must be <= 4MB and > 0")
+                }
+                if r.lazyBuf == 0 && blockSize < defaultBlockSize {
+                        r.lazyBuf = blockSize
+                }
+                r.maxBlock = blockSize
+                return nil
+        }
+}
+
+// ReaderAllocBlock allows to control upfront stream allocations
+// and not allocate for frames bigger than this initially.
+// If frames bigger than this is seen a bigger buffer will be allocated.
+//
+// Default is 1MB, which is default output size.
+func ReaderAllocBlock(blockSize int) ReaderOption {
+        return func(r *Reader) error {
+                if blockSize > maxBlockSize || blockSize < 1024 {
+                        return errors.New("s2: invalid ReaderAllocBlock. Must be <= 4MB and >= 1024")
+                }
+                r.lazyBuf = blockSize
+                return nil
+        }
+}
+
+// ReaderIgnoreStreamIdentifier will make the reader skip the expected
+// stream identifier at the beginning of the stream.
+// This can be used when serving a stream that has been forwarded to a specific point.
+func ReaderIgnoreStreamIdentifier() ReaderOption {
+        return func(r *Reader) error {
+                r.ignoreStreamID = true
+                return nil
+        }
+}
+
+// ReaderSkippableCB will register a callback for chuncks with the specified ID.
+// ID must be a Reserved skippable chunks ID, 0x80-0xfd (inclusive).
+// For each chunk with the ID, the callback is called with the content.
+// Any returned non-nil error will abort decompression.
+// Only one callback per ID is supported, latest sent will be used.
+func ReaderSkippableCB(id uint8, fn func(r io.Reader) error) ReaderOption {
+        return func(r *Reader) error {
+                if id < 0x80 || id > 0xfd {
+                        return fmt.Errorf("ReaderSkippableCB: Invalid id provided, must be 0x80-0xfd (inclusive)")
+                }
+                r.skippableCB[id] = fn
+                return nil
+        }
+}
+
+// ReaderIgnoreCRC will make the reader skip CRC calculation and checks.
+func ReaderIgnoreCRC() ReaderOption {
+        return func(r *Reader) error {
+                r.ignoreCRC = true
+                return nil
+        }
+}
+
+// Reader is an io.Reader that can read Snappy-compressed bytes.
+type Reader struct {
+        r           io.Reader
+        err         error
+        decoded     []byte
+        buf         []byte
+        skippableCB [0x80]func(r io.Reader) error
+        blockStart  int64 // Uncompressed offset at start of current.
+        index       *Index
+
+        // decoded[i:j] contains decoded bytes that have not yet been passed on.
+        i, j int
+        // maximum block size allowed.
+        maxBlock int
+        // maximum expected buffer size.
+        maxBufSize int
+        // alloc a buffer this size if > 0.
+        lazyBuf        int
+        readHeader     bool
+        paramsOK       bool
+        snappyFrame    bool
+        ignoreStreamID bool
+        ignoreCRC      bool
+}
+
+// GetBufferCapacity returns the capacity of the internal buffer.
+// This might be useful to know when reusing the same reader in combination
+// with the lazy buffer option.
+func (r *Reader) GetBufferCapacity() int {
+        return cap(r.buf)
+}
+
+// ensureBufferSize will ensure that the buffer can take at least n bytes.
+// If false is returned the buffer exceeds maximum allowed size.
+func (r *Reader) ensureBufferSize(n int) bool {
+        if n > r.maxBufSize {
+                r.err = ErrCorrupt
+                return false
+        }
+        if cap(r.buf) >= n {
+                return true
+        }
+        // Realloc buffer.
+        r.buf = make([]byte, n)
+        return true
+}
+
+// Reset discards any buffered data, resets all state, and switches the Snappy
+// reader to read from r. This permits reusing a Reader rather than allocating
+// a new one.
+func (r *Reader) Reset(reader io.Reader) {
+        if !r.paramsOK {
+                return
+        }
+        r.index = nil
+        r.r = reader
+        r.err = nil
+        r.i = 0
+        r.j = 0
+        r.blockStart = 0
+        r.readHeader = r.ignoreStreamID
+}
+
+func (r *Reader) readFull(p []byte, allowEOF bool) (ok bool) {
+        if _, r.err = io.ReadFull(r.r, p); r.err != nil {
+                if r.err == io.ErrUnexpectedEOF || (r.err == io.EOF && !allowEOF) {
+                        r.err = ErrCorrupt
+                }
+                return false
+        }
+        return true
+}
+
+// skippable will skip n bytes.
+// If the supplied reader supports seeking that is used.
+// tmp is used as a temporary buffer for reading.
+// The supplied slice does not need to be the size of the read.
+func (r *Reader) skippable(tmp []byte, n int, allowEOF bool, id uint8) (ok bool) {
+        if id < 0x80 {
+                r.err = fmt.Errorf("interbal error: skippable id < 0x80")
+                return false
+        }
+        if fn := r.skippableCB[id-0x80]; fn != nil {
+                rd := io.LimitReader(r.r, int64(n))
+                r.err = fn(rd)
+                if r.err != nil {
+                        return false
+                }
+                _, r.err = io.CopyBuffer(ioutil.Discard, rd, tmp)
+                return r.err == nil
+        }
+        if rs, ok := r.r.(io.ReadSeeker); ok {
+                _, err := rs.Seek(int64(n), io.SeekCurrent)
+                if err == nil {
+                        return true
+                }
+                if err == io.ErrUnexpectedEOF || (r.err == io.EOF && !allowEOF) {
+                        r.err = ErrCorrupt
+                        return false
+                }
+        }
+        for n > 0 {
+                if n < len(tmp) {
+                        tmp = tmp[:n]
+                }
+                if _, r.err = io.ReadFull(r.r, tmp); r.err != nil {
+                        if r.err == io.ErrUnexpectedEOF || (r.err == io.EOF && !allowEOF) {
+                                r.err = ErrCorrupt
+                        }
+                        return false
+                }
+                n -= len(tmp)
+        }
+        return true
+}
+
+// Read satisfies the io.Reader interface.
+func (r *Reader) Read(p []byte) (int, error) {
+        if r.err != nil {
+                return 0, r.err
+        }
+        for {
+                if r.i < r.j {
+                        n := copy(p, r.decoded[r.i:r.j])
+                        r.i += n
+                        return n, nil
+                }
+                if !r.readFull(r.buf[:4], true) {
+                        return 0, r.err
+                }
+                chunkType := r.buf[0]
+                if !r.readHeader {
+                        if chunkType != chunkTypeStreamIdentifier {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+                        r.readHeader = true
+                }
+                chunkLen := int(r.buf[1]) | int(r.buf[2])<<8 | int(r.buf[3])<<16
+
+                // The chunk types are specified at
+                // https://github.com/google/snappy/blob/master/framing_format.txt
+                switch chunkType {
+                case chunkTypeCompressedData:
+                        r.blockStart += int64(r.j)
+                        // Section 4.2. Compressed data (chunk type 0x00).
+                        if chunkLen < checksumSize {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+                        if !r.ensureBufferSize(chunkLen) {
+                                if r.err == nil {
+                                        r.err = ErrUnsupported
+                                }
+                                return 0, r.err
+                        }
+                        buf := r.buf[:chunkLen]
+                        if !r.readFull(buf, false) {
+                                return 0, r.err
+                        }
+                        checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
+                        buf = buf[checksumSize:]
+
+                        n, err := DecodedLen(buf)
+                        if err != nil {
+                                r.err = err
+                                return 0, r.err
+                        }
+                        if r.snappyFrame && n > maxSnappyBlockSize {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+
+                        if n > len(r.decoded) {
+                                if n > r.maxBlock {
+                                        r.err = ErrCorrupt
+                                        return 0, r.err
+                                }
+                                r.decoded = make([]byte, n)
+                        }
+                        if _, err := Decode(r.decoded, buf); err != nil {
+                                r.err = err
+                                return 0, r.err
+                        }
+                        if !r.ignoreCRC && crc(r.decoded[:n]) != checksum {
+                                r.err = ErrCRC
+                                return 0, r.err
+                        }
+                        r.i, r.j = 0, n
+                        continue
+
+                case chunkTypeUncompressedData:
+                        r.blockStart += int64(r.j)
+                        // Section 4.3. Uncompressed data (chunk type 0x01).
+                        if chunkLen < checksumSize {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+                        if !r.ensureBufferSize(chunkLen) {
+                                if r.err == nil {
+                                        r.err = ErrUnsupported
+                                }
+                                return 0, r.err
+                        }
+                        buf := r.buf[:checksumSize]
+                        if !r.readFull(buf, false) {
+                                return 0, r.err
+                        }
+                        checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
+                        // Read directly into r.decoded instead of via r.buf.
+                        n := chunkLen - checksumSize
+                        if r.snappyFrame && n > maxSnappyBlockSize {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+                        if n > len(r.decoded) {
+                                if n > r.maxBlock {
+                                        r.err = ErrCorrupt
+                                        return 0, r.err
+                                }
+                                r.decoded = make([]byte, n)
+                        }
+                        if !r.readFull(r.decoded[:n], false) {
+                                return 0, r.err
+                        }
+                        if !r.ignoreCRC && crc(r.decoded[:n]) != checksum {
+                                r.err = ErrCRC
+                                return 0, r.err
+                        }
+                        r.i, r.j = 0, n
+                        continue
+
+                case chunkTypeStreamIdentifier:
+                        // Section 4.1. Stream identifier (chunk type 0xff).
+                        if chunkLen != len(magicBody) {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+                        if !r.readFull(r.buf[:len(magicBody)], false) {
+                                return 0, r.err
+                        }
+                        if string(r.buf[:len(magicBody)]) != magicBody {
+                                if string(r.buf[:len(magicBody)]) != magicBodySnappy {
+                                        r.err = ErrCorrupt
+                                        return 0, r.err
+                                } else {
+                                        r.snappyFrame = true
+                                }
+                        } else {
+                                r.snappyFrame = false
+                        }
+                        continue
+                }
+
+                if chunkType <= 0x7f {
+                        // Section 4.5. Reserved unskippable chunks (chunk types 0x02-0x7f).
+                        // fmt.Printf("ERR chunktype: 0x%x\n", chunkType)
+                        r.err = ErrUnsupported
+                        return 0, r.err
+                }
+                // Section 4.4 Padding (chunk type 0xfe).
+                // Section 4.6. Reserved skippable chunks (chunk types 0x80-0xfd).
+                if chunkLen > maxChunkSize {
+                        // fmt.Printf("ERR chunkLen: 0x%x\n", chunkLen)
+                        r.err = ErrUnsupported
+                        return 0, r.err
+                }
+
+                // fmt.Printf("skippable: ID: 0x%x, len: 0x%x\n", chunkType, chunkLen)
+                if !r.skippable(r.buf, chunkLen, false, chunkType) {
+                        return 0, r.err
+                }
+        }
+}
+
+// DecodeConcurrent will decode the full stream to w.
+// This function should not be combined with reading, seeking or other operations.
+// Up to 'concurrent' goroutines will be used.
+// If <= 0, runtime.NumCPU will be used.
+// On success the number of bytes decompressed nil and is returned.
+// This is mainly intended for bigger streams.
+func (r *Reader) DecodeConcurrent(w io.Writer, concurrent int) (written int64, err error) {
+        if r.i > 0 || r.j > 0 || r.blockStart > 0 {
+                return 0, errors.New("DecodeConcurrent called after ")
+        }
+        if concurrent <= 0 {
+                concurrent = runtime.NumCPU()
+        }
+
+        // Write to output
+        var errMu sync.Mutex
+        var aErr error
+        setErr := func(e error) (ok bool) {
+                errMu.Lock()
+                defer errMu.Unlock()
+                if e == nil {
+                        return aErr == nil
+                }
+                if aErr == nil {
+                        aErr = e
+                }
+                return false
+        }
+        hasErr := func() (ok bool) {
+                errMu.Lock()
+                v := aErr != nil
+                errMu.Unlock()
+                return v
+        }
+
+        var aWritten int64
+        toRead := make(chan []byte, concurrent)
+        writtenBlocks := make(chan []byte, concurrent)
+        queue := make(chan chan []byte, concurrent)
+        reUse := make(chan chan []byte, concurrent)
+        for i := 0; i < concurrent; i++ {
+                toRead <- make([]byte, 0, r.maxBufSize)
+                writtenBlocks <- make([]byte, 0, r.maxBufSize)
+                reUse <- make(chan []byte, 1)
+        }
+        // Writer
+        var wg sync.WaitGroup
+        wg.Add(1)
+        go func() {
+                defer wg.Done()
+                for toWrite := range queue {
+                        entry := <-toWrite
+                        reUse <- toWrite
+                        if hasErr() {
+                                writtenBlocks <- entry
+                                continue
+                        }
+                        n, err := w.Write(entry)
+                        want := len(entry)
+                        writtenBlocks <- entry
+                        if err != nil {
+                                setErr(err)
+                                continue
+                        }
+                        if n != want {
+                                setErr(io.ErrShortWrite)
+                                continue
+                        }
+                        aWritten += int64(n)
+                }
+        }()
+
+        // Reader
+        defer func() {
+                close(queue)
+                if r.err != nil {
+                        err = r.err
+                        setErr(r.err)
+                }
+                wg.Wait()
+                if err == nil {
+                        err = aErr
+                }
+                written = aWritten
+        }()
+
+        for !hasErr() {
+                if !r.readFull(r.buf[:4], true) {
+                        if r.err == io.EOF {
+                                r.err = nil
+                        }
+                        return 0, r.err
+                }
+                chunkType := r.buf[0]
+                if !r.readHeader {
+                        if chunkType != chunkTypeStreamIdentifier {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+                        r.readHeader = true
+                }
+                chunkLen := int(r.buf[1]) | int(r.buf[2])<<8 | int(r.buf[3])<<16
+
+                // The chunk types are specified at
+                // https://github.com/google/snappy/blob/master/framing_format.txt
+                switch chunkType {
+                case chunkTypeCompressedData:
+                        r.blockStart += int64(r.j)
+                        // Section 4.2. Compressed data (chunk type 0x00).
+                        if chunkLen < checksumSize {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+                        if chunkLen > r.maxBufSize {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+                        orgBuf := <-toRead
+                        buf := orgBuf[:chunkLen]
+
+                        if !r.readFull(buf, false) {
+                                return 0, r.err
+                        }
+
+                        checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
+                        buf = buf[checksumSize:]
+
+                        n, err := DecodedLen(buf)
+                        if err != nil {
+                                r.err = err
+                                return 0, r.err
+                        }
+                        if r.snappyFrame && n > maxSnappyBlockSize {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+
+                        if n > r.maxBlock {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+                        wg.Add(1)
+
+                        decoded := <-writtenBlocks
+                        entry := <-reUse
+                        queue <- entry
+                        go func() {
+                                defer wg.Done()
+                                decoded = decoded[:n]
+                                _, err := Decode(decoded, buf)
+                                toRead <- orgBuf
+                                if err != nil {
+                                        writtenBlocks <- decoded
+                                        setErr(err)
+                                        return
+                                }
+                                if !r.ignoreCRC && crc(decoded) != checksum {
+                                        writtenBlocks <- decoded
+                                        setErr(ErrCRC)
+                                        return
+                                }
+                                entry <- decoded
+                        }()
+                        continue
+
+                case chunkTypeUncompressedData:
+
+                        // Section 4.3. Uncompressed data (chunk type 0x01).
+                        if chunkLen < checksumSize {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+                        if chunkLen > r.maxBufSize {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+                        // Grab write buffer
+                        orgBuf := <-writtenBlocks
+                        buf := orgBuf[:checksumSize]
+                        if !r.readFull(buf, false) {
+                                return 0, r.err
+                        }
+                        checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
+                        // Read content.
+                        n := chunkLen - checksumSize
+
+                        if r.snappyFrame && n > maxSnappyBlockSize {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+                        if n > r.maxBlock {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+                        // Read uncompressed
+                        buf = orgBuf[:n]
+                        if !r.readFull(buf, false) {
+                                return 0, r.err
+                        }
+
+                        if !r.ignoreCRC && crc(buf) != checksum {
+                                r.err = ErrCRC
+                                return 0, r.err
+                        }
+                        entry := <-reUse
+                        queue <- entry
+                        entry <- buf
+                        continue
+
+                case chunkTypeStreamIdentifier:
+                        // Section 4.1. Stream identifier (chunk type 0xff).
+                        if chunkLen != len(magicBody) {
+                                r.err = ErrCorrupt
+                                return 0, r.err
+                        }
+                        if !r.readFull(r.buf[:len(magicBody)], false) {
+                                return 0, r.err
+                        }
+                        if string(r.buf[:len(magicBody)]) != magicBody {
+                                if string(r.buf[:len(magicBody)]) != magicBodySnappy {
+                                        r.err = ErrCorrupt
+                                        return 0, r.err
+                                } else {
+                                        r.snappyFrame = true
+                                }
+                        } else {
+                                r.snappyFrame = false
+                        }
+                        continue
+                }
+
+                if chunkType <= 0x7f {
+                        // Section 4.5. Reserved unskippable chunks (chunk types 0x02-0x7f).
+                        // fmt.Printf("ERR chunktype: 0x%x\n", chunkType)
+                        r.err = ErrUnsupported
+                        return 0, r.err
+                }
+                // Section 4.4 Padding (chunk type 0xfe).
+                // Section 4.6. Reserved skippable chunks (chunk types 0x80-0xfd).
+                if chunkLen > maxChunkSize {
+                        // fmt.Printf("ERR chunkLen: 0x%x\n", chunkLen)
+                        r.err = ErrUnsupported
+                        return 0, r.err
+                }
+
+                // fmt.Printf("skippable: ID: 0x%x, len: 0x%x\n", chunkType, chunkLen)
+                if !r.skippable(r.buf, chunkLen, false, chunkType) {
+                        return 0, r.err
+                }
+        }
+        return 0, r.err
+}
+
+// Skip will skip n bytes forward in the decompressed output.
+// For larger skips this consumes less CPU and is faster than reading output and discarding it.
+// CRC is not checked on skipped blocks.
+// io.ErrUnexpectedEOF is returned if the stream ends before all bytes have been skipped.
+// If a decoding error is encountered subsequent calls to Read will also fail.
+func (r *Reader) Skip(n int64) error {
+        if n < 0 {
+                return errors.New("attempted negative skip")
+        }
+        if r.err != nil {
+                return r.err
+        }
+
+        for n > 0 {
+                if r.i < r.j {
+                        // Skip in buffer.
+                        // decoded[i:j] contains decoded bytes that have not yet been passed on.
+                        left := int64(r.j - r.i)
+                        if left >= n {
+                                tmp := int64(r.i) + n
+                                if tmp > math.MaxInt32 {
+                                        return errors.New("s2: internal overflow in skip")
+                                }
+                                r.i = int(tmp)
+                                return nil
+                        }
+                        n -= int64(r.j - r.i)
+                        r.i = r.j
+                }
+
+                // Buffer empty; read blocks until we have content.
+                if !r.readFull(r.buf[:4], true) {
+                        if r.err == io.EOF {
+                                r.err = io.ErrUnexpectedEOF
+                        }
+                        return r.err
+                }
+                chunkType := r.buf[0]
+                if !r.readHeader {
+                        if chunkType != chunkTypeStreamIdentifier {
+                                r.err = ErrCorrupt
+                                return r.err
+                        }
+                        r.readHeader = true
+                }
+                chunkLen := int(r.buf[1]) | int(r.buf[2])<<8 | int(r.buf[3])<<16
+
+                // The chunk types are specified at
+                // https://github.com/google/snappy/blob/master/framing_format.txt
+                switch chunkType {
+                case chunkTypeCompressedData:
+                        r.blockStart += int64(r.j)
+                        // Section 4.2. Compressed data (chunk type 0x00).
+                        if chunkLen < checksumSize {
+                                r.err = ErrCorrupt
+                                return r.err
+                        }
+                        if !r.ensureBufferSize(chunkLen) {
+                                if r.err == nil {
+                                        r.err = ErrUnsupported
+                                }
+                                return r.err
+                        }
+                        buf := r.buf[:chunkLen]
+                        if !r.readFull(buf, false) {
+                                return r.err
+                        }
+                        checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
+                        buf = buf[checksumSize:]
+
+                        dLen, err := DecodedLen(buf)
+                        if err != nil {
+                                r.err = err
+                                return r.err
+                        }
+                        if dLen > r.maxBlock {
+                                r.err = ErrCorrupt
+                                return r.err
+                        }
+                        // Check if destination is within this block
+                        if int64(dLen) > n {
+                                if len(r.decoded) < dLen {
+                                        r.decoded = make([]byte, dLen)
+                                }
+                                if _, err := Decode(r.decoded, buf); err != nil {
+                                        r.err = err
+                                        return r.err
+                                }
+                                if crc(r.decoded[:dLen]) != checksum {
+                                        r.err = ErrCorrupt
+                                        return r.err
+                                }
+                        } else {
+                                // Skip block completely
+                                n -= int64(dLen)
+                                r.blockStart += int64(dLen)
+                                dLen = 0
+                        }
+                        r.i, r.j = 0, dLen
+                        continue
+                case chunkTypeUncompressedData:
+                        r.blockStart += int64(r.j)
+                        // Section 4.3. Uncompressed data (chunk type 0x01).
+                        if chunkLen < checksumSize {
+                                r.err = ErrCorrupt
+                                return r.err
+                        }
+                        if !r.ensureBufferSize(chunkLen) {
+                                if r.err != nil {
+                                        r.err = ErrUnsupported
+                                }
+                                return r.err
+                        }
+                        buf := r.buf[:checksumSize]
+                        if !r.readFull(buf, false) {
+                                return r.err
+                        }
+                        checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
+                        // Read directly into r.decoded instead of via r.buf.
+                        n2 := chunkLen - checksumSize
+                        if n2 > len(r.decoded) {
+                                if n2 > r.maxBlock {
+                                        r.err = ErrCorrupt
+                                        return r.err
+                                }
+                                r.decoded = make([]byte, n2)
+                        }
+                        if !r.readFull(r.decoded[:n2], false) {
+                                return r.err
+                        }
+                        if int64(n2) < n {
+                                if crc(r.decoded[:n2]) != checksum {
+                                        r.err = ErrCorrupt
+                                        return r.err
+                                }
+                        }
+                        r.i, r.j = 0, n2
+                        continue
+                case chunkTypeStreamIdentifier:
+                        // Section 4.1. Stream identifier (chunk type 0xff).
+                        if chunkLen != len(magicBody) {
+                                r.err = ErrCorrupt
+                                return r.err
+                        }
+                        if !r.readFull(r.buf[:len(magicBody)], false) {
+                                return r.err
+                        }
+                        if string(r.buf[:len(magicBody)]) != magicBody {
+                                if string(r.buf[:len(magicBody)]) != magicBodySnappy {
+                                        r.err = ErrCorrupt
+                                        return r.err
+                                }
+                        }
+
+                        continue
+                }
+
+                if chunkType <= 0x7f {
+                        // Section 4.5. Reserved unskippable chunks (chunk types 0x02-0x7f).
+                        r.err = ErrUnsupported
+                        return r.err
+                }
+                if chunkLen > maxChunkSize {
+                        r.err = ErrUnsupported
+                        return r.err
+                }
+                // Section 4.4 Padding (chunk type 0xfe).
+                // Section 4.6. Reserved skippable chunks (chunk types 0x80-0xfd).
+                if !r.skippable(r.buf, chunkLen, false, chunkType) {
+                        return r.err
+                }
+        }
+        return nil
+}
+
+// ReadSeeker provides random or forward seeking in compressed content.
+// See Reader.ReadSeeker
+type ReadSeeker struct {
+        *Reader
+        readAtMu sync.Mutex
+}
+
+// ReadSeeker will return an io.ReadSeeker and io.ReaderAt
+// compatible version of the reader.
+// If 'random' is specified the returned io.Seeker can be used for
+// random seeking, otherwise only forward seeking is supported.
+// Enabling random seeking requires the original input to support
+// the io.Seeker interface.
+// A custom index can be specified which will be used if supplied.
+// When using a custom index, it will not be read from the input stream.
+// The ReadAt position will affect regular reads and the current position of Seek.
+// So using Read after ReadAt will continue from where the ReadAt stopped.
+// No functions should be used concurrently.
+// The returned ReadSeeker contains a shallow reference to the existing Reader,
+// meaning changes performed to one is reflected in the other.
+func (r *Reader) ReadSeeker(random bool, index []byte) (*ReadSeeker, error) {
+        // Read index if provided.
+        if len(index) != 0 {
+                if r.index == nil {
+                        r.index = &Index{}
+                }
+                if _, err := r.index.Load(index); err != nil {
+                        return nil, ErrCantSeek{Reason: "loading index returned: " + err.Error()}
+                }
+        }
+
+        // Check if input is seekable
+        rs, ok := r.r.(io.ReadSeeker)
+        if !ok {
+                if !random {
+                        return &ReadSeeker{Reader: r}, nil
+                }
+                return nil, ErrCantSeek{Reason: "input stream isn't seekable"}
+        }
+
+        if r.index != nil {
+                // Seekable and index, ok...
+                return &ReadSeeker{Reader: r}, nil
+        }
+
+        // Load from stream.
+        r.index = &Index{}
+
+        // Read current position.
+        pos, err := rs.Seek(0, io.SeekCurrent)
+        if err != nil {
+                return nil, ErrCantSeek{Reason: "seeking input returned: " + err.Error()}
+        }
+        err = r.index.LoadStream(rs)
+        if err != nil {
+                if err == ErrUnsupported {
+                        // If we don't require random seeking, reset input and return.
+                        if !random {
+                                _, err = rs.Seek(pos, io.SeekStart)
+                                if err != nil {
+                                        return nil, ErrCantSeek{Reason: "resetting stream returned: " + err.Error()}
+                                }
+                                r.index = nil
+                                return &ReadSeeker{Reader: r}, nil
+                        }
+                        return nil, ErrCantSeek{Reason: "input stream does not contain an index"}
+                }
+                return nil, ErrCantSeek{Reason: "reading index returned: " + err.Error()}
+        }
+
+        // reset position.
+        _, err = rs.Seek(pos, io.SeekStart)
+        if err != nil {
+                return nil, ErrCantSeek{Reason: "seeking input returned: " + err.Error()}
+        }
+        return &ReadSeeker{Reader: r}, nil
+}
+
+// Seek allows seeking in compressed data.
+func (r *ReadSeeker) Seek(offset int64, whence int) (int64, error) {
+        if r.err != nil {
+                if !errors.Is(r.err, io.EOF) {
+                        return 0, r.err
+                }
+                // Reset on EOF
+                r.err = nil
+        }
+
+        // Calculate absolute offset.
+        absOffset := offset
+
+        switch whence {
+        case io.SeekStart:
+        case io.SeekCurrent:
+                absOffset = r.blockStart + int64(r.i) + offset
+        case io.SeekEnd:
+                if r.index == nil {
+                        return 0, ErrUnsupported
+                }
+                absOffset = r.index.TotalUncompressed + offset
+        default:
+                r.err = ErrUnsupported
+                return 0, r.err
+        }
+
+        if absOffset < 0 {
+                return 0, errors.New("seek before start of file")
+        }
+
+        if !r.readHeader {
+                // Make sure we read the header.
+                _, r.err = r.Read([]byte{})
+                if r.err != nil {
+                        return 0, r.err
+                }
+        }
+
+        // If we are inside current block no need to seek.
+        // This includes no offset changes.
+        if absOffset >= r.blockStart && absOffset < r.blockStart+int64(r.j) {
+                r.i = int(absOffset - r.blockStart)
+                return r.blockStart + int64(r.i), nil
+        }
+
+        rs, ok := r.r.(io.ReadSeeker)
+        if r.index == nil || !ok {
+                currOffset := r.blockStart + int64(r.i)
+                if absOffset >= currOffset {
+                        err := r.Skip(absOffset - currOffset)
+                        return r.blockStart + int64(r.i), err
+                }
+                return 0, ErrUnsupported
+        }
+
+        // We can seek and we have an index.
+        c, u, err := r.index.Find(absOffset)
+        if err != nil {
+                return r.blockStart + int64(r.i), err
+        }
+
+        // Seek to next block
+        _, err = rs.Seek(c, io.SeekStart)
+        if err != nil {
+                return 0, err
+        }
+
+        r.i = r.j                     // Remove rest of current block.
+        r.blockStart = u - int64(r.j) // Adjust current block start for accounting.
+        if u < absOffset {
+                // Forward inside block
+                return absOffset, r.Skip(absOffset - u)
+        }
+        if u > absOffset {
+                return 0, fmt.Errorf("s2 seek: (internal error) u (%d) > absOffset (%d)", u, absOffset)
+        }
+        return absOffset, nil
+}
+
+// ReadAt reads len(p) bytes into p starting at offset off in the
+// underlying input source. It returns the number of bytes
+// read (0 <= n <= len(p)) and any error encountered.
+//
+// When ReadAt returns n < len(p), it returns a non-nil error
+// explaining why more bytes were not returned. In this respect,
+// ReadAt is stricter than Read.
+//
+// Even if ReadAt returns n < len(p), it may use all of p as scratch
+// space during the call. If some data is available but not len(p) bytes,
+// ReadAt blocks until either all the data is available or an error occurs.
+// In this respect ReadAt is different from Read.
+//
+// If the n = len(p) bytes returned by ReadAt are at the end of the
+// input source, ReadAt may return either err == EOF or err == nil.
+//
+// If ReadAt is reading from an input source with a seek offset,
+// ReadAt should not affect nor be affected by the underlying
+// seek offset.
+//
+// Clients of ReadAt can execute parallel ReadAt calls on the
+// same input source. This is however not recommended.
+func (r *ReadSeeker) ReadAt(p []byte, offset int64) (int, error) {
+        r.readAtMu.Lock()
+        defer r.readAtMu.Unlock()
+        _, err := r.Seek(offset, io.SeekStart)
+        if err != nil {
+                return 0, err
+        }
+        n := 0
+        for n < len(p) {
+                n2, err := r.Read(p[n:])
+                if err != nil {
+                        // This will include io.EOF
+                        return n + n2, err
+                }
+                n += n2
+        }
+        return n, nil
+}
+
+// ReadByte satisfies the io.ByteReader interface.
+func (r *Reader) ReadByte() (byte, error) {
+        if r.err != nil {
+                return 0, r.err
+        }
+        if r.i < r.j {
+                c := r.decoded[r.i]
+                r.i++
+                return c, nil
+        }
+        var tmp [1]byte
+        for i := 0; i < 10; i++ {
+                n, err := r.Read(tmp[:])
+                if err != nil {
+                        return 0, err
+                }
+                if n == 1 {
+                        return tmp[0], nil
+                }
+        }
+        return 0, io.ErrNoProgress
+}
+
+// SkippableCB will register a callback for chunks with the specified ID.
+// ID must be a Reserved skippable chunks ID, 0x80-0xfe (inclusive).
+// For each chunk with the ID, the callback is called with the content.
+// Any returned non-nil error will abort decompression.
+// Only one callback per ID is supported, latest sent will be used.
+// Sending a nil function will disable previous callbacks.
+func (r *Reader) SkippableCB(id uint8, fn func(r io.Reader) error) error {
+        if id < 0x80 || id > chunkTypePadding {
+                return fmt.Errorf("ReaderSkippableCB: Invalid id provided, must be 0x80-0xfe (inclusive)")
+        }
+        r.skippableCB[id] = fn
+        return nil
+}
diff --git a/vendor/github.com/klauspost/compress/s2/s2.go b/vendor/github.com/klauspost/compress/s2/s2.go
new file mode 100644
index 0000000..dae3f73
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/s2.go
@@ -0,0 +1,143 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Copyright (c) 2019 Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package s2 implements the S2 compression format.
+//
+// S2 is an extension of Snappy. Similar to Snappy S2 is aimed for high throughput,
+// which is why it features concurrent compression for bigger payloads.
+//
+// Decoding is compatible with Snappy compressed content,
+// but content compressed with S2 cannot be decompressed by Snappy.
+//
+// For more information on Snappy/S2 differences see README in: https://github.com/klauspost/compress/tree/master/s2
+//
+// There are actually two S2 formats: block and stream. They are related,
+// but different: trying to decompress block-compressed data as a S2 stream
+// will fail, and vice versa. The block format is the Decode and Encode
+// functions and the stream format is the Reader and Writer types.
+//
+// A "better" compression option is available. This will trade some compression
+// speed
+//
+// The block format, the more common case, is used when the complete size (the
+// number of bytes) of the original data is known upfront, at the time
+// compression starts. The stream format, also known as the framing format, is
+// for when that isn't always true.
+//
+// Blocks to not offer much data protection, so it is up to you to
+// add data validation of decompressed blocks.
+//
+// Streams perform CRC validation of the decompressed data.
+// Stream compression will also be performed on multiple CPU cores concurrently
+// significantly improving throughput.
+package s2
+
+import (
+        "bytes"
+        "hash/crc32"
+)
+
+/*
+Each encoded block begins with the varint-encoded length of the decoded data,
+followed by a sequence of chunks. Chunks begin and end on byte boundaries. The
+first byte of each chunk is broken into its 2 least and 6 most significant bits
+called l and m: l ranges in [0, 4) and m ranges in [0, 64). l is the chunk tag.
+Zero means a literal tag. All other values mean a copy tag.
+
+For literal tags:
+  - If m < 60, the next 1 + m bytes are literal bytes.
+  - Otherwise, let n be the little-endian unsigned integer denoted by the next
+    m - 59 bytes. The next 1 + n bytes after that are literal bytes.
+
+For copy tags, length bytes are copied from offset bytes ago, in the style of
+Lempel-Ziv compression algorithms. In particular:
+  - For l == 1, the offset ranges in [0, 1<<11) and the length in [4, 12).
+    The length is 4 + the low 3 bits of m. The high 3 bits of m form bits 8-10
+    of the offset. The next byte is bits 0-7 of the offset.
+  - For l == 2, the offset ranges in [0, 1<<16) and the length in [1, 65).
+    The length is 1 + m. The offset is the little-endian unsigned integer
+    denoted by the next 2 bytes.
+  - For l == 3, the offset ranges in [0, 1<<32) and the length in
+    [1, 65). The length is 1 + m. The offset is the little-endian unsigned
+    integer denoted by the next 4 bytes.
+*/
+const (
+        tagLiteral = 0x00
+        tagCopy1   = 0x01
+        tagCopy2   = 0x02
+        tagCopy4   = 0x03
+)
+
+const (
+        checksumSize     = 4
+        chunkHeaderSize  = 4
+        magicChunk       = "\xff\x06\x00\x00" + magicBody
+        magicChunkSnappy = "\xff\x06\x00\x00" + magicBodySnappy
+        magicBodySnappy  = "sNaPpY"
+        magicBody        = "S2sTwO"
+
+        // maxBlockSize is the maximum size of the input to encodeBlock.
+        //
+        // For the framing format (Writer type instead of Encode function),
+        // this is the maximum uncompressed size of a block.
+        maxBlockSize = 4 << 20
+
+        // minBlockSize is the minimum size of block setting when creating a writer.
+        minBlockSize = 4 << 10
+
+        skippableFrameHeader = 4
+        maxChunkSize         = 1<<24 - 1 // 16777215
+
+        // Default block size
+        defaultBlockSize = 1 << 20
+
+        // maxSnappyBlockSize is the maximum snappy block size.
+        maxSnappyBlockSize = 1 << 16
+
+        obufHeaderLen = checksumSize + chunkHeaderSize
+)
+
+const (
+        chunkTypeCompressedData   = 0x00
+        chunkTypeUncompressedData = 0x01
+        ChunkTypeIndex            = 0x99
+        chunkTypePadding          = 0xfe
+        chunkTypeStreamIdentifier = 0xff
+)
+
+var crcTable = crc32.MakeTable(crc32.Castagnoli)
+
+// crc implements the checksum specified in section 3 of
+// https://github.com/google/snappy/blob/master/framing_format.txt
+func crc(b []byte) uint32 {
+        c := crc32.Update(0, crcTable, b)
+        return c>>15 | c<<17 + 0xa282ead8
+}
+
+// literalExtraSize returns the extra size of encoding n literals.
+// n should be >= 0 and <= math.MaxUint32.
+func literalExtraSize(n int64) int64 {
+        if n == 0 {
+                return 0
+        }
+        switch {
+        case n < 60:
+                return 1
+        case n < 1<<8:
+                return 2
+        case n < 1<<16:
+                return 3
+        case n < 1<<24:
+                return 4
+        default:
+                return 5
+        }
+}
+
+type byter interface {
+        Bytes() []byte
+}
+
+var _ byter = &bytes.Buffer{}
diff --git a/vendor/github.com/klauspost/compress/s2/writer.go b/vendor/github.com/klauspost/compress/s2/writer.go
new file mode 100644
index 0000000..089cd36
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/s2/writer.go
@@ -0,0 +1,1020 @@
+// Copyright 2011 The Snappy-Go Authors. All rights reserved.
+// Copyright (c) 2019+ Klaus Post. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s2
+
+import (
+        "crypto/rand"
+        "encoding/binary"
+        "errors"
+        "fmt"
+        "io"
+        "runtime"
+        "sync"
+)
+
+const (
+        levelUncompressed = iota + 1
+        levelFast
+        levelBetter
+        levelBest
+)
+
+// NewWriter returns a new Writer that compresses to w, using the
+// framing format described at
+// https://github.com/google/snappy/blob/master/framing_format.txt
+//
+// Users must call Close to guarantee all data has been forwarded to
+// the underlying io.Writer and that resources are released.
+// They may also call Flush zero or more times before calling Close.
+func NewWriter(w io.Writer, opts ...WriterOption) *Writer {
+        w2 := Writer{
+                blockSize:   defaultBlockSize,
+                concurrency: runtime.GOMAXPROCS(0),
+                randSrc:     rand.Reader,
+                level:       levelFast,
+        }
+        for _, opt := range opts {
+                if err := opt(&w2); err != nil {
+                        w2.errState = err
+                        return &w2
+                }
+        }
+        w2.obufLen = obufHeaderLen + MaxEncodedLen(w2.blockSize)
+        w2.paramsOK = true
+        w2.ibuf = make([]byte, 0, w2.blockSize)
+        w2.buffers.New = func() interface{} {
+                return make([]byte, w2.obufLen)
+        }
+        w2.Reset(w)
+        return &w2
+}
+
+// Writer is an io.Writer that can write Snappy-compressed bytes.
+type Writer struct {
+        errMu    sync.Mutex
+        errState error
+
+        // ibuf is a buffer for the incoming (uncompressed) bytes.
+        ibuf []byte
+
+        blockSize     int
+        obufLen       int
+        concurrency   int
+        written       int64
+        uncompWritten int64 // Bytes sent to compression
+        output        chan chan result
+        buffers       sync.Pool
+        pad           int
+
+        writer    io.Writer
+        randSrc   io.Reader
+        writerWg  sync.WaitGroup
+        index     Index
+        customEnc func(dst, src []byte) int
+
+        // wroteStreamHeader is whether we have written the stream header.
+        wroteStreamHeader bool
+        paramsOK          bool
+        snappy            bool
+        flushOnWrite      bool
+        appendIndex       bool
+        level             uint8
+}
+
+type result struct {
+        b []byte
+        // Uncompressed start offset
+        startOffset int64
+}
+
+// err returns the previously set error.
+// If no error has been set it is set to err if not nil.
+func (w *Writer) err(err error) error {
+        w.errMu.Lock()
+        errSet := w.errState
+        if errSet == nil && err != nil {
+                w.errState = err
+                errSet = err
+        }
+        w.errMu.Unlock()
+        return errSet
+}
+
+// Reset discards the writer's state and switches the Snappy writer to write to w.
+// This permits reusing a Writer rather than allocating a new one.
+func (w *Writer) Reset(writer io.Writer) {
+        if !w.paramsOK {
+                return
+        }
+        // Close previous writer, if any.
+        if w.output != nil {
+                close(w.output)
+                w.writerWg.Wait()
+                w.output = nil
+        }
+        w.errState = nil
+        w.ibuf = w.ibuf[:0]
+        w.wroteStreamHeader = false
+        w.written = 0
+        w.writer = writer
+        w.uncompWritten = 0
+        w.index.reset(w.blockSize)
+
+        // If we didn't get a writer, stop here.
+        if writer == nil {
+                return
+        }
+        // If no concurrency requested, don't spin up writer goroutine.
+        if w.concurrency == 1 {
+                return
+        }
+
+        toWrite := make(chan chan result, w.concurrency)
+        w.output = toWrite
+        w.writerWg.Add(1)
+
+        // Start a writer goroutine that will write all output in order.
+        go func() {
+                defer w.writerWg.Done()
+
+                // Get a queued write.
+                for write := range toWrite {
+                        // Wait for the data to be available.
+                        input := <-write
+                        in := input.b
+                        if len(in) > 0 {
+                                if w.err(nil) == nil {
+                                        // Don't expose data from previous buffers.
+                                        toWrite := in[:len(in):len(in)]
+                                        // Write to output.
+                                        n, err := writer.Write(toWrite)
+                                        if err == nil && n != len(toWrite) {
+                                                err = io.ErrShortBuffer
+                                        }
+                                        _ = w.err(err)
+                                        w.err(w.index.add(w.written, input.startOffset))
+                                        w.written += int64(n)
+                                }
+                        }
+                        if cap(in) >= w.obufLen {
+                                w.buffers.Put(in)
+                        }
+                        // close the incoming write request.
+                        // This can be used for synchronizing flushes.
+                        close(write)
+                }
+        }()
+}
+
+// Write satisfies the io.Writer interface.
+func (w *Writer) Write(p []byte) (nRet int, errRet error) {
+        if err := w.err(nil); err != nil {
+                return 0, err
+        }
+        if w.flushOnWrite {
+                return w.write(p)
+        }
+        // If we exceed the input buffer size, start writing
+        for len(p) > (cap(w.ibuf)-len(w.ibuf)) && w.err(nil) == nil {
+                var n int
+                if len(w.ibuf) == 0 {
+                        // Large write, empty buffer.
+                        // Write directly from p to avoid copy.
+                        n, _ = w.write(p)
+                } else {
+                        n = copy(w.ibuf[len(w.ibuf):cap(w.ibuf)], p)
+                        w.ibuf = w.ibuf[:len(w.ibuf)+n]
+                        w.write(w.ibuf)
+                        w.ibuf = w.ibuf[:0]
+                }
+                nRet += n
+                p = p[n:]
+        }
+        if err := w.err(nil); err != nil {
+                return nRet, err
+        }
+        // p should always be able to fit into w.ibuf now.
+        n := copy(w.ibuf[len(w.ibuf):cap(w.ibuf)], p)
+        w.ibuf = w.ibuf[:len(w.ibuf)+n]
+        nRet += n
+        return nRet, nil
+}
+
+// ReadFrom implements the io.ReaderFrom interface.
+// Using this is typically more efficient since it avoids a memory copy.
+// ReadFrom reads data from r until EOF or error.
+// The return value n is the number of bytes read.
+// Any error except io.EOF encountered during the read is also returned.
+func (w *Writer) ReadFrom(r io.Reader) (n int64, err error) {
+        if err := w.err(nil); err != nil {
+                return 0, err
+        }
+        if len(w.ibuf) > 0 {
+                err := w.Flush()
+                if err != nil {
+                        return 0, err
+                }
+        }
+        if br, ok := r.(byter); ok {
+                buf := br.Bytes()
+                if err := w.EncodeBuffer(buf); err != nil {
+                        return 0, err
+                }
+                return int64(len(buf)), w.Flush()
+        }
+        for {
+                inbuf := w.buffers.Get().([]byte)[:w.blockSize+obufHeaderLen]
+                n2, err := io.ReadFull(r, inbuf[obufHeaderLen:])
+                if err != nil {
+                        if err == io.ErrUnexpectedEOF {
+                                err = io.EOF
+                        }
+                        if err != io.EOF {
+                                return n, w.err(err)
+                        }
+                }
+                if n2 == 0 {
+                        break
+                }
+                n += int64(n2)
+                err2 := w.writeFull(inbuf[:n2+obufHeaderLen])
+                if w.err(err2) != nil {
+                        break
+                }
+
+                if err != nil {
+                        // We got EOF and wrote everything
+                        break
+                }
+        }
+
+        return n, w.err(nil)
+}
+
+// AddSkippableBlock will add a skippable block to the stream.
+// The ID must be 0x80-0xfe (inclusive).
+// Length of the skippable block must be <= 16777215 bytes.
+func (w *Writer) AddSkippableBlock(id uint8, data []byte) (err error) {
+        if err := w.err(nil); err != nil {
+                return err
+        }
+        if len(data) == 0 {
+                return nil
+        }
+        if id < 0x80 || id > chunkTypePadding {
+                return fmt.Errorf("invalid skippable block id %x", id)
+        }
+        if len(data) > maxChunkSize {
+                return fmt.Errorf("skippable block excessed maximum size")
+        }
+        var header [4]byte
+        chunkLen := 4 + len(data)
+        header[0] = id
+        header[1] = uint8(chunkLen >> 0)
+        header[2] = uint8(chunkLen >> 8)
+        header[3] = uint8(chunkLen >> 16)
+        if w.concurrency == 1 {
+                write := func(b []byte) error {
+                        n, err := w.writer.Write(b)
+                        if err = w.err(err); err != nil {
+                                return err
+                        }
+                        if n != len(data) {
+                                return w.err(io.ErrShortWrite)
+                        }
+                        w.written += int64(n)
+                        return w.err(nil)
+                }
+                if !w.wroteStreamHeader {
+                        w.wroteStreamHeader = true
+                        if w.snappy {
+                                if err := write([]byte(magicChunkSnappy)); err != nil {
+                                        return err
+                                }
+                        } else {
+                                if err := write([]byte(magicChunk)); err != nil {
+                                        return err
+                                }
+                        }
+                }
+                if err := write(header[:]); err != nil {
+                        return err
+                }
+                if err := write(data); err != nil {
+                        return err
+                }
+        }
+
+        // Create output...
+        if !w.wroteStreamHeader {
+                w.wroteStreamHeader = true
+                hWriter := make(chan result)
+                w.output <- hWriter
+                if w.snappy {
+                        hWriter <- result{startOffset: w.uncompWritten, b: []byte(magicChunkSnappy)}
+                } else {
+                        hWriter <- result{startOffset: w.uncompWritten, b: []byte(magicChunk)}
+                }
+        }
+
+        // Copy input.
+        inbuf := w.buffers.Get().([]byte)[:4]
+        copy(inbuf, header[:])
+        inbuf = append(inbuf, data...)
+
+        output := make(chan result, 1)
+        // Queue output.
+        w.output <- output
+        output <- result{startOffset: w.uncompWritten, b: inbuf}
+
+        return nil
+}
+
+// EncodeBuffer will add a buffer to the stream.
+// This is the fastest way to encode a stream,
+// but the input buffer cannot be written to by the caller
+// until Flush or Close has been called when concurrency != 1.
+//
+// If you cannot control that, use the regular Write function.
+//
+// Note that input is not buffered.
+// This means that each write will result in discrete blocks being created.
+// For buffered writes, use the regular Write function.
+func (w *Writer) EncodeBuffer(buf []byte) (err error) {
+        if err := w.err(nil); err != nil {
+                return err
+        }
+
+        if w.flushOnWrite {
+                _, err := w.write(buf)
+                return err
+        }
+        // Flush queued data first.
+        if len(w.ibuf) > 0 {
+                err := w.Flush()
+                if err != nil {
+                        return err
+                }
+        }
+        if w.concurrency == 1 {
+                _, err := w.writeSync(buf)
+                return err
+        }
+
+        // Spawn goroutine and write block to output channel.
+        if !w.wroteStreamHeader {
+                w.wroteStreamHeader = true
+                hWriter := make(chan result)
+                w.output <- hWriter
+                if w.snappy {
+                        hWriter <- result{startOffset: w.uncompWritten, b: []byte(magicChunkSnappy)}
+                } else {
+                        hWriter <- result{startOffset: w.uncompWritten, b: []byte(magicChunk)}
+                }
+        }
+
+        for len(buf) > 0 {
+                // Cut input.
+                uncompressed := buf
+                if len(uncompressed) > w.blockSize {
+                        uncompressed = uncompressed[:w.blockSize]
+                }
+                buf = buf[len(uncompressed):]
+                // Get an output buffer.
+                obuf := w.buffers.Get().([]byte)[:len(uncompressed)+obufHeaderLen]
+                output := make(chan result)
+                // Queue output now, so we keep order.
+                w.output <- output
+                res := result{
+                        startOffset: w.uncompWritten,
+                }
+                w.uncompWritten += int64(len(uncompressed))
+                go func() {
+                        checksum := crc(uncompressed)
+
+                        // Set to uncompressed.
+                        chunkType := uint8(chunkTypeUncompressedData)
+                        chunkLen := 4 + len(uncompressed)
+
+                        // Attempt compressing.
+                        n := binary.PutUvarint(obuf[obufHeaderLen:], uint64(len(uncompressed)))
+                        n2 := w.encodeBlock(obuf[obufHeaderLen+n:], uncompressed)
+
+                        // Check if we should use this, or store as uncompressed instead.
+                        if n2 > 0 {
+                                chunkType = uint8(chunkTypeCompressedData)
+                                chunkLen = 4 + n + n2
+                                obuf = obuf[:obufHeaderLen+n+n2]
+                        } else {
+                                // copy uncompressed
+                                copy(obuf[obufHeaderLen:], uncompressed)
+                        }
+
+                        // Fill in the per-chunk header that comes before the body.
+                        obuf[0] = chunkType
+                        obuf[1] = uint8(chunkLen >> 0)
+                        obuf[2] = uint8(chunkLen >> 8)
+                        obuf[3] = uint8(chunkLen >> 16)
+                        obuf[4] = uint8(checksum >> 0)
+                        obuf[5] = uint8(checksum >> 8)
+                        obuf[6] = uint8(checksum >> 16)
+                        obuf[7] = uint8(checksum >> 24)
+
+                        // Queue final output.
+                        res.b = obuf
+                        output <- res
+                }()
+        }
+        return nil
+}
+
+func (w *Writer) encodeBlock(obuf, uncompressed []byte) int {
+        if w.customEnc != nil {
+                if ret := w.customEnc(obuf, uncompressed); ret >= 0 {
+                        return ret
+                }
+        }
+        if w.snappy {
+                switch w.level {
+                case levelFast:
+                        return encodeBlockSnappy(obuf, uncompressed)
+                case levelBetter:
+                        return encodeBlockBetterSnappy(obuf, uncompressed)
+                case levelBest:
+                        return encodeBlockBestSnappy(obuf, uncompressed)
+                }
+                return 0
+        }
+        switch w.level {
+        case levelFast:
+                return encodeBlock(obuf, uncompressed)
+        case levelBetter:
+                return encodeBlockBetter(obuf, uncompressed)
+        case levelBest:
+                return encodeBlockBest(obuf, uncompressed, nil)
+        }
+        return 0
+}
+
+func (w *Writer) write(p []byte) (nRet int, errRet error) {
+        if err := w.err(nil); err != nil {
+                return 0, err
+        }
+        if w.concurrency == 1 {
+                return w.writeSync(p)
+        }
+
+        // Spawn goroutine and write block to output channel.
+        for len(p) > 0 {
+                if !w.wroteStreamHeader {
+                        w.wroteStreamHeader = true
+                        hWriter := make(chan result)
+                        w.output <- hWriter
+                        if w.snappy {
+                                hWriter <- result{startOffset: w.uncompWritten, b: []byte(magicChunkSnappy)}
+                        } else {
+                                hWriter <- result{startOffset: w.uncompWritten, b: []byte(magicChunk)}
+                        }
+                }
+
+                var uncompressed []byte
+                if len(p) > w.blockSize {
+                        uncompressed, p = p[:w.blockSize], p[w.blockSize:]
+                } else {
+                        uncompressed, p = p, nil
+                }
+
+                // Copy input.
+                // If the block is incompressible, this is used for the result.
+                inbuf := w.buffers.Get().([]byte)[:len(uncompressed)+obufHeaderLen]
+                obuf := w.buffers.Get().([]byte)[:w.obufLen]
+                copy(inbuf[obufHeaderLen:], uncompressed)
+                uncompressed = inbuf[obufHeaderLen:]
+
+                output := make(chan result)
+                // Queue output now, so we keep order.
+                w.output <- output
+                res := result{
+                        startOffset: w.uncompWritten,
+                }
+                w.uncompWritten += int64(len(uncompressed))
+
+                go func() {
+                        checksum := crc(uncompressed)
+
+                        // Set to uncompressed.
+                        chunkType := uint8(chunkTypeUncompressedData)
+                        chunkLen := 4 + len(uncompressed)
+
+                        // Attempt compressing.
+                        n := binary.PutUvarint(obuf[obufHeaderLen:], uint64(len(uncompressed)))
+                        n2 := w.encodeBlock(obuf[obufHeaderLen+n:], uncompressed)
+
+                        // Check if we should use this, or store as uncompressed instead.
+                        if n2 > 0 {
+                                chunkType = uint8(chunkTypeCompressedData)
+                                chunkLen = 4 + n + n2
+                                obuf = obuf[:obufHeaderLen+n+n2]
+                        } else {
+                                // Use input as output.
+                                obuf, inbuf = inbuf, obuf
+                        }
+
+                        // Fill in the per-chunk header that comes before the body.
+                        obuf[0] = chunkType
+                        obuf[1] = uint8(chunkLen >> 0)
+                        obuf[2] = uint8(chunkLen >> 8)
+                        obuf[3] = uint8(chunkLen >> 16)
+                        obuf[4] = uint8(checksum >> 0)
+                        obuf[5] = uint8(checksum >> 8)
+                        obuf[6] = uint8(checksum >> 16)
+                        obuf[7] = uint8(checksum >> 24)
+
+                        // Queue final output.
+                        res.b = obuf
+                        output <- res
+
+                        // Put unused buffer back in pool.
+                        w.buffers.Put(inbuf)
+                }()
+                nRet += len(uncompressed)
+        }
+        return nRet, nil
+}
+
+// writeFull is a special version of write that will always write the full buffer.
+// Data to be compressed should start at offset obufHeaderLen and fill the remainder of the buffer.
+// The data will be written as a single block.
+// The caller is not allowed to use inbuf after this function has been called.
+func (w *Writer) writeFull(inbuf []byte) (errRet error) {
+        if err := w.err(nil); err != nil {
+                return err
+        }
+
+        if w.concurrency == 1 {
+                _, err := w.writeSync(inbuf[obufHeaderLen:])
+                return err
+        }
+
+        // Spawn goroutine and write block to output channel.
+        if !w.wroteStreamHeader {
+                w.wroteStreamHeader = true
+                hWriter := make(chan result)
+                w.output <- hWriter
+                if w.snappy {
+                        hWriter <- result{startOffset: w.uncompWritten, b: []byte(magicChunkSnappy)}
+                } else {
+                        hWriter <- result{startOffset: w.uncompWritten, b: []byte(magicChunk)}
+                }
+        }
+
+        // Get an output buffer.
+        obuf := w.buffers.Get().([]byte)[:w.obufLen]
+        uncompressed := inbuf[obufHeaderLen:]
+
+        output := make(chan result)
+        // Queue output now, so we keep order.
+        w.output <- output
+        res := result{
+                startOffset: w.uncompWritten,
+        }
+        w.uncompWritten += int64(len(uncompressed))
+
+        go func() {
+                checksum := crc(uncompressed)
+
+                // Set to uncompressed.
+                chunkType := uint8(chunkTypeUncompressedData)
+                chunkLen := 4 + len(uncompressed)
+
+                // Attempt compressing.
+                n := binary.PutUvarint(obuf[obufHeaderLen:], uint64(len(uncompressed)))
+                n2 := w.encodeBlock(obuf[obufHeaderLen+n:], uncompressed)
+
+                // Check if we should use this, or store as uncompressed instead.
+                if n2 > 0 {
+                        chunkType = uint8(chunkTypeCompressedData)
+                        chunkLen = 4 + n + n2
+                        obuf = obuf[:obufHeaderLen+n+n2]
+                } else {
+                        // Use input as output.
+                        obuf, inbuf = inbuf, obuf
+                }
+
+                // Fill in the per-chunk header that comes before the body.
+                obuf[0] = chunkType
+                obuf[1] = uint8(chunkLen >> 0)
+                obuf[2] = uint8(chunkLen >> 8)
+                obuf[3] = uint8(chunkLen >> 16)
+                obuf[4] = uint8(checksum >> 0)
+                obuf[5] = uint8(checksum >> 8)
+                obuf[6] = uint8(checksum >> 16)
+                obuf[7] = uint8(checksum >> 24)
+
+                // Queue final output.
+                res.b = obuf
+                output <- res
+
+                // Put unused buffer back in pool.
+                w.buffers.Put(inbuf)
+        }()
+        return nil
+}
+
+func (w *Writer) writeSync(p []byte) (nRet int, errRet error) {
+        if err := w.err(nil); err != nil {
+                return 0, err
+        }
+        if !w.wroteStreamHeader {
+                w.wroteStreamHeader = true
+                var n int
+                var err error
+                if w.snappy {
+                        n, err = w.writer.Write([]byte(magicChunkSnappy))
+                } else {
+                        n, err = w.writer.Write([]byte(magicChunk))
+                }
+                if err != nil {
+                        return 0, w.err(err)
+                }
+                if n != len(magicChunk) {
+                        return 0, w.err(io.ErrShortWrite)
+                }
+                w.written += int64(n)
+        }
+
+        for len(p) > 0 {
+                var uncompressed []byte
+                if len(p) > w.blockSize {
+                        uncompressed, p = p[:w.blockSize], p[w.blockSize:]
+                } else {
+                        uncompressed, p = p, nil
+                }
+
+                obuf := w.buffers.Get().([]byte)[:w.obufLen]
+                checksum := crc(uncompressed)
+
+                // Set to uncompressed.
+                chunkType := uint8(chunkTypeUncompressedData)
+                chunkLen := 4 + len(uncompressed)
+
+                // Attempt compressing.
+                n := binary.PutUvarint(obuf[obufHeaderLen:], uint64(len(uncompressed)))
+                n2 := w.encodeBlock(obuf[obufHeaderLen+n:], uncompressed)
+
+                if n2 > 0 {
+                        chunkType = uint8(chunkTypeCompressedData)
+                        chunkLen = 4 + n + n2
+                        obuf = obuf[:obufHeaderLen+n+n2]
+                } else {
+                        obuf = obuf[:8]
+                }
+
+                // Fill in the per-chunk header that comes before the body.
+                obuf[0] = chunkType
+                obuf[1] = uint8(chunkLen >> 0)
+                obuf[2] = uint8(chunkLen >> 8)
+                obuf[3] = uint8(chunkLen >> 16)
+                obuf[4] = uint8(checksum >> 0)
+                obuf[5] = uint8(checksum >> 8)
+                obuf[6] = uint8(checksum >> 16)
+                obuf[7] = uint8(checksum >> 24)
+
+                n, err := w.writer.Write(obuf)
+                if err != nil {
+                        return 0, w.err(err)
+                }
+                if n != len(obuf) {
+                        return 0, w.err(io.ErrShortWrite)
+                }
+                w.err(w.index.add(w.written, w.uncompWritten))
+                w.written += int64(n)
+                w.uncompWritten += int64(len(uncompressed))
+
+                if chunkType == chunkTypeUncompressedData {
+                        // Write uncompressed data.
+                        n, err := w.writer.Write(uncompressed)
+                        if err != nil {
+                                return 0, w.err(err)
+                        }
+                        if n != len(uncompressed) {
+                                return 0, w.err(io.ErrShortWrite)
+                        }
+                        w.written += int64(n)
+                }
+                w.buffers.Put(obuf)
+                // Queue final output.
+                nRet += len(uncompressed)
+        }
+        return nRet, nil
+}
+
+// Flush flushes the Writer to its underlying io.Writer.
+// This does not apply padding.
+func (w *Writer) Flush() error {
+        if err := w.err(nil); err != nil {
+                return err
+        }
+
+        // Queue any data still in input buffer.
+        if len(w.ibuf) != 0 {
+                if !w.wroteStreamHeader {
+                        _, err := w.writeSync(w.ibuf)
+                        w.ibuf = w.ibuf[:0]
+                        return w.err(err)
+                } else {
+                        _, err := w.write(w.ibuf)
+                        w.ibuf = w.ibuf[:0]
+                        err = w.err(err)
+                        if err != nil {
+                                return err
+                        }
+                }
+        }
+        if w.output == nil {
+                return w.err(nil)
+        }
+
+        // Send empty buffer
+        res := make(chan result)
+        w.output <- res
+        // Block until this has been picked up.
+        res <- result{b: nil, startOffset: w.uncompWritten}
+        // When it is closed, we have flushed.
+        <-res
+        return w.err(nil)
+}
+
+// Close calls Flush and then closes the Writer.
+// Calling Close multiple times is ok,
+// but calling CloseIndex after this will make it not return the index.
+func (w *Writer) Close() error {
+        _, err := w.closeIndex(w.appendIndex)
+        return err
+}
+
+// CloseIndex calls Close and returns an index on first call.
+// This is not required if you are only adding index to a stream.
+func (w *Writer) CloseIndex() ([]byte, error) {
+        return w.closeIndex(true)
+}
+
+func (w *Writer) closeIndex(idx bool) ([]byte, error) {
+        err := w.Flush()
+        if w.output != nil {
+                close(w.output)
+                w.writerWg.Wait()
+                w.output = nil
+        }
+
+        var index []byte
+        if w.err(err) == nil && w.writer != nil {
+                // Create index.
+                if idx {
+                        compSize := int64(-1)
+                        if w.pad <= 1 {
+                                compSize = w.written
+                        }
+                        index = w.index.appendTo(w.ibuf[:0], w.uncompWritten, compSize)
+                        // Count as written for padding.
+                        if w.appendIndex {
+                                w.written += int64(len(index))
+                        }
+                }
+
+                if w.pad > 1 {
+                        tmp := w.ibuf[:0]
+                        if len(index) > 0 {
+                                // Allocate another buffer.
+                                tmp = w.buffers.Get().([]byte)[:0]
+                                defer w.buffers.Put(tmp)
+                        }
+                        add := calcSkippableFrame(w.written, int64(w.pad))
+                        frame, err := skippableFrame(tmp, add, w.randSrc)
+                        if err = w.err(err); err != nil {
+                                return nil, err
+                        }
+                        n, err2 := w.writer.Write(frame)
+                        if err2 == nil && n != len(frame) {
+                                err2 = io.ErrShortWrite
+                        }
+                        _ = w.err(err2)
+                }
+                if len(index) > 0 && w.appendIndex {
+                        n, err2 := w.writer.Write(index)
+                        if err2 == nil && n != len(index) {
+                                err2 = io.ErrShortWrite
+                        }
+                        _ = w.err(err2)
+                }
+        }
+        err = w.err(errClosed)
+        if err == errClosed {
+                return index, nil
+        }
+        return nil, err
+}
+
+// calcSkippableFrame will return a total size to be added for written
+// to be divisible by multiple.
+// The value will always be > skippableFrameHeader.
+// The function will panic if written < 0 or wantMultiple <= 0.
+func calcSkippableFrame(written, wantMultiple int64) int {
+        if wantMultiple <= 0 {
+                panic("wantMultiple <= 0")
+        }
+        if written < 0 {
+                panic("written < 0")
+        }
+        leftOver := written % wantMultiple
+        if leftOver == 0 {
+                return 0
+        }
+        toAdd := wantMultiple - leftOver
+        for toAdd < skippableFrameHeader {
+                toAdd += wantMultiple
+        }
+        return int(toAdd)
+}
+
+// skippableFrame will add a skippable frame with a total size of bytes.
+// total should be >= skippableFrameHeader and < maxBlockSize + skippableFrameHeader
+func skippableFrame(dst []byte, total int, r io.Reader) ([]byte, error) {
+        if total == 0 {
+                return dst, nil
+        }
+        if total < skippableFrameHeader {
+                return dst, fmt.Errorf("s2: requested skippable frame (%d) < 4", total)
+        }
+        if int64(total) >= maxBlockSize+skippableFrameHeader {
+                return dst, fmt.Errorf("s2: requested skippable frame (%d) >= max 1<<24", total)
+        }
+        // Chunk type 0xfe "Section 4.4 Padding (chunk type 0xfe)"
+        dst = append(dst, chunkTypePadding)
+        f := uint32(total - skippableFrameHeader)
+        // Add chunk length.
+        dst = append(dst, uint8(f), uint8(f>>8), uint8(f>>16))
+        // Add data
+        start := len(dst)
+        dst = append(dst, make([]byte, f)...)
+        _, err := io.ReadFull(r, dst[start:])
+        return dst, err
+}
+
+var errClosed = errors.New("s2: Writer is closed")
+
+// WriterOption is an option for creating a encoder.
+type WriterOption func(*Writer) error
+
+// WriterConcurrency will set the concurrency,
+// meaning the maximum number of decoders to run concurrently.
+// The value supplied must be at least 1.
+// By default this will be set to GOMAXPROCS.
+func WriterConcurrency(n int) WriterOption {
+        return func(w *Writer) error {
+                if n <= 0 {
+                        return errors.New("concurrency must be at least 1")
+                }
+                w.concurrency = n
+                return nil
+        }
+}
+
+// WriterAddIndex will append an index to the end of a stream
+// when it is closed.
+func WriterAddIndex() WriterOption {
+        return func(w *Writer) error {
+                w.appendIndex = true
+                return nil
+        }
+}
+
+// WriterBetterCompression will enable better compression.
+// EncodeBetter compresses better than Encode but typically with a
+// 10-40% speed decrease on both compression and decompression.
+func WriterBetterCompression() WriterOption {
+        return func(w *Writer) error {
+                w.level = levelBetter
+                return nil
+        }
+}
+
+// WriterBestCompression will enable better compression.
+// EncodeBetter compresses better than Encode but typically with a
+// big speed decrease on compression.
+func WriterBestCompression() WriterOption {
+        return func(w *Writer) error {
+                w.level = levelBest
+                return nil
+        }
+}
+
+// WriterUncompressed will bypass compression.
+// The stream will be written as uncompressed blocks only.
+// If concurrency is > 1 CRC and output will still be done async.
+func WriterUncompressed() WriterOption {
+        return func(w *Writer) error {
+                w.level = levelUncompressed
+                return nil
+        }
+}
+
+// WriterBlockSize allows to override the default block size.
+// Blocks will be this size or smaller.
+// Minimum size is 4KB and and maximum size is 4MB.
+//
+// Bigger blocks may give bigger throughput on systems with many cores,
+// and will increase compression slightly, but it will limit the possible
+// concurrency for smaller payloads for both encoding and decoding.
+// Default block size is 1MB.
+//
+// When writing Snappy compatible output using WriterSnappyCompat,
+// the maximum block size is 64KB.
+func WriterBlockSize(n int) WriterOption {
+        return func(w *Writer) error {
+                if w.snappy && n > maxSnappyBlockSize || n < minBlockSize {
+                        return errors.New("s2: block size too large. Must be <= 64K and >=4KB on for snappy compatible output")
+                }
+                if n > maxBlockSize || n < minBlockSize {
+                        return errors.New("s2: block size too large. Must be <= 4MB and >=4KB")
+                }
+                w.blockSize = n
+                return nil
+        }
+}
+
+// WriterPadding will add padding to all output so the size will be a multiple of n.
+// This can be used to obfuscate the exact output size or make blocks of a certain size.
+// The contents will be a skippable frame, so it will be invisible by the decoder.
+// n must be > 0 and <= 4MB.
+// The padded area will be filled with data from crypto/rand.Reader.
+// The padding will be applied whenever Close is called on the writer.
+func WriterPadding(n int) WriterOption {
+        return func(w *Writer) error {
+                if n <= 0 {
+                        return fmt.Errorf("s2: padding must be at least 1")
+                }
+                // No need to waste our time.
+                if n == 1 {
+                        w.pad = 0
+                }
+                if n > maxBlockSize {
+                        return fmt.Errorf("s2: padding must less than 4MB")
+                }
+                w.pad = n
+                return nil
+        }
+}
+
+// WriterPaddingSrc will get random data for padding from the supplied source.
+// By default crypto/rand is used.
+func WriterPaddingSrc(reader io.Reader) WriterOption {
+        return func(w *Writer) error {
+                w.randSrc = reader
+                return nil
+        }
+}
+
+// WriterSnappyCompat will write snappy compatible output.
+// The output can be decompressed using either snappy or s2.
+// If block size is more than 64KB it is set to that.
+func WriterSnappyCompat() WriterOption {
+        return func(w *Writer) error {
+                w.snappy = true
+                if w.blockSize > 64<<10 {
+                        // We choose 8 bytes less than 64K, since that will make literal emits slightly more effective.
+                        // And allows us to skip some size checks.
+                        w.blockSize = (64 << 10) - 8
+                }
+                return nil
+        }
+}
+
+// WriterFlushOnWrite will compress blocks on each call to the Write function.
+//
+// This is quite inefficient as blocks size will depend on the write size.
+//
+// Use WriterConcurrency(1) to also make sure that output is flushed.
+// When Write calls return, otherwise they will be written when compression is done.
+func WriterFlushOnWrite() WriterOption {
+        return func(w *Writer) error {
+                w.flushOnWrite = true
+                return nil
+        }
+}
+
+// WriterCustomEncoder allows to override the encoder for blocks on the stream.
+// The function must compress 'src' into 'dst' and return the bytes used in dst as an integer.
+// Block size (initial varint) should not be added by the encoder.
+// Returning value 0 indicates the block could not be compressed.
+// Returning a negative value indicates that compression should be attempted.
+// The function should expect to be called concurrently.
+func WriterCustomEncoder(fn func(dst, src []byte) int) WriterOption {
+        return func(w *Writer) error {
+                w.customEnc = fn
+                return nil
+        }
+}
diff --git a/vendor/github.com/klauspost/cpuid/v2/.gitignore b/vendor/github.com/klauspost/cpuid/v2/.gitignore
new file mode 100644
index 0000000..daf913b
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/.gitignore
@@ -0,0 +1,24 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
diff --git a/vendor/github.com/klauspost/cpuid/v2/.goreleaser.yml b/vendor/github.com/klauspost/cpuid/v2/.goreleaser.yml
new file mode 100644
index 0000000..944cc00
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/.goreleaser.yml
@@ -0,0 +1,74 @@
+# This is an example goreleaser.yaml file with some sane defaults.
+# Make sure to check the documentation at http://goreleaser.com
+
+builds:
+  -
+    id: "cpuid"
+    binary: cpuid
+    main: ./cmd/cpuid/main.go
+    env:
+      - CGO_ENABLED=0
+    flags:
+      - -ldflags=-s -w
+    goos:
+      - aix
+      - linux
+      - freebsd
+      - netbsd
+      - windows
+      - darwin
+    goarch:
+      - 386
+      - amd64
+      - arm64
+    goarm:
+      - 7
+
+archives:
+  -
+    id: cpuid
+    name_template: "cpuid-{{ .Os }}_{{ .Arch }}_{{ .Version }}"
+    replacements:
+      aix: AIX
+      darwin: OSX
+      linux: Linux
+      windows: Windows
+      386: i386
+      amd64: x86_64
+      freebsd: FreeBSD
+      netbsd: NetBSD
+    format_overrides:
+      - goos: windows
+        format: zip
+    files:
+      - LICENSE
+checksum:
+  name_template: 'checksums.txt'
+snapshot:
+  name_template: "{{ .Tag }}-next"
+changelog:
+  sort: asc
+  filters:
+    exclude:
+    - '^doc:'
+    - '^docs:'
+    - '^test:'
+    - '^tests:'
+    - '^Update\sREADME.md'
+
+nfpms:
+  -
+    file_name_template: "cpuid_package_{{ .Version }}_{{ .Os }}_{{ .Arch }}"
+    vendor: Klaus Post
+    homepage: https://github.com/klauspost/cpuid
+    maintainer: Klaus Post <[email protected]>
+    description: CPUID Tool
+    license: BSD 3-Clause
+    formats:
+      - deb
+      - rpm
+    replacements:
+      darwin: Darwin
+      linux: Linux
+      freebsd: FreeBSD
+      amd64: x86_64
diff --git a/vendor/github.com/klauspost/cpuid/v2/CONTRIBUTING.txt b/vendor/github.com/klauspost/cpuid/v2/CONTRIBUTING.txt
new file mode 100644
index 0000000..452d28e
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/CONTRIBUTING.txt
@@ -0,0 +1,35 @@
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2015- Klaus Post & Contributors.
+Email: [email protected]
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
diff --git a/vendor/github.com/klauspost/cpuid/v2/LICENSE b/vendor/github.com/klauspost/cpuid/v2/LICENSE
new file mode 100644
index 0000000..5cec7ee
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/LICENSE
@@ -0,0 +1,22 @@
+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.
+
diff --git a/vendor/github.com/klauspost/cpuid/v2/README.md b/vendor/github.com/klauspost/cpuid/v2/README.md
new file mode 100644
index 0000000..30f8d29
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/README.md
@@ -0,0 +1,497 @@
+# cpuid
+Package cpuid provides information about the CPU running the current program.
+
+CPU features are detected on startup, and kept for fast access through the life of the application.
+Currently x86 / x64 (AMD64/i386) and ARM (ARM64) is supported, and no external C (cgo) code is used, which should make the library very easy to use.
+
+You can access the CPU information by accessing the shared CPU variable of the cpuid library.
+
+Package home: https://github.com/klauspost/cpuid
+
+[![PkgGoDev](https://pkg.go.dev/badge/github.com/klauspost/cpuid)](https://pkg.go.dev/github.com/klauspost/cpuid/v2)
+[![Go](https://github.com/klauspost/cpuid/actions/workflows/go.yml/badge.svg)](https://github.com/klauspost/cpuid/actions/workflows/go.yml)
+
+## installing
+
+`go get -u github.com/klauspost/cpuid/v2` using modules.
+Drop `v2` for others.
+
+Installing binary:
+
+`go install github.com/klauspost/cpuid/v2/cmd/cpuid@latest`
+
+Or download binaries from release page: https://github.com/klauspost/cpuid/releases
+
+### Homebrew
+
+For macOS/Linux users, you can install via [brew](https://brew.sh/)
+
+```sh
+$ brew install cpuid
+```
+
+## example
+
+```Go
+package main
+
+import (
+        "fmt"
+        "strings"
+
+        . "github.com/klauspost/cpuid/v2"
+)
+
+func main() {
+        // Print basic CPU information:
+        fmt.Println("Name:", CPU.BrandName)
+        fmt.Println("PhysicalCores:", CPU.PhysicalCores)
+        fmt.Println("ThreadsPerCore:", CPU.ThreadsPerCore)
+        fmt.Println("LogicalCores:", CPU.LogicalCores)
+        fmt.Println("Family", CPU.Family, "Model:", CPU.Model, "Vendor ID:", CPU.VendorID)
+        fmt.Println("Features:", strings.Join(CPU.FeatureSet(), ","))
+        fmt.Println("Cacheline bytes:", CPU.CacheLine)
+        fmt.Println("L1 Data Cache:", CPU.Cache.L1D, "bytes")
+        fmt.Println("L1 Instruction Cache:", CPU.Cache.L1I, "bytes")
+        fmt.Println("L2 Cache:", CPU.Cache.L2, "bytes")
+        fmt.Println("L3 Cache:", CPU.Cache.L3, "bytes")
+        fmt.Println("Frequency", CPU.Hz, "hz")
+
+        // Test if we have these specific features:
+        if CPU.Supports(SSE, SSE2) {
+                fmt.Println("We have Streaming SIMD 2 Extensions")
+        }
+}
+```
+
+Sample output:
+```
+>go run main.go
+Name: AMD Ryzen 9 3950X 16-Core Processor
+PhysicalCores: 16
+ThreadsPerCore: 2
+LogicalCores: 32
+Family 23 Model: 113 Vendor ID: AMD
+Features: ADX,AESNI,AVX,AVX2,BMI1,BMI2,CLMUL,CMOV,CX16,F16C,FMA3,HTT,HYPERVISOR,LZCNT,MMX,MMXEXT,NX,POPCNT,RDRAND,RDSEED,RDTSCP,SHA,SSE,SSE2,SSE3,SSE4,SSE42,SSE4A,SSSE3
+Cacheline bytes: 64
+L1 Data Cache: 32768 bytes
+L1 Instruction Cache: 32768 bytes
+L2 Cache: 524288 bytes
+L3 Cache: 16777216 bytes
+Frequency 0 hz
+We have Streaming SIMD 2 Extensions
+```
+
+# usage
+
+The `cpuid.CPU` provides access to CPU features. Use `cpuid.CPU.Supports()` to check for CPU features.
+A faster `cpuid.CPU.Has()` is provided which will usually be inlined by the gc compiler.  
+
+To test a larger number of features, they can be combined using `f := CombineFeatures(CMOV, CMPXCHG8, X87, FXSR, MMX, SYSCALL, SSE, SSE2)`, etc.
+This can be using with `cpuid.CPU.HasAll(f)` to quickly test if all features are supported.
+
+Note that for some cpu/os combinations some features will not be detected.
+`amd64` has rather good support and should work reliably on all platforms.
+
+Note that hypervisors may not pass through all CPU features through to the guest OS,
+so even if your host supports a feature it may not be visible on guests.
+
+## arm64 feature detection
+
+Not all operating systems provide ARM features directly 
+and there is no safe way to do so for the rest.
+
+Currently `arm64/linux` and `arm64/freebsd` should be quite reliable. 
+`arm64/darwin` adds features expected from the M1 processor, but a lot remains undetected.
+
+A `DetectARM()` can be used if you are able to control your deployment,
+it will detect CPU features, but may crash if the OS doesn't intercept the calls.
+A `-cpu.arm` flag for detecting unsafe ARM features can be added. See below.
+ 
+Note that currently only features are detected on ARM, 
+no additional information is currently available. 
+
+## flags
+
+It is possible to add flags that affects cpu detection.
+
+For this the `Flags()` command is provided.
+
+This must be called *before* `flag.Parse()` AND after the flags have been parsed `Detect()` must be called.
+
+This means that any detection used in `init()` functions will not contain these flags.
+
+Example:
+
+```Go
+package main
+
+import (
+        "flag"
+        "fmt"
+        "strings"
+
+        "github.com/klauspost/cpuid/v2"
+)
+
+func main() {
+        cpuid.Flags()
+        flag.Parse()
+        cpuid.Detect()
+
+        // Test if we have these specific features:
+        if cpuid.CPU.Supports(cpuid.SSE, cpuid.SSE2) {
+                fmt.Println("We have Streaming SIMD 2 Extensions")
+        }
+}
+```
+
+## commandline
+
+Download as binary from: https://github.com/klauspost/cpuid/releases
+
+Install from source:
+
+`go install github.com/klauspost/cpuid/v2/cmd/cpuid@latest`
+
+### Example
+
+```
+λ cpuid
+Name: AMD Ryzen 9 3950X 16-Core Processor
+Vendor String: AuthenticAMD
+Vendor ID: AMD
+PhysicalCores: 16
+Threads Per Core: 2
+Logical Cores: 32
+CPU Family 23 Model: 113
+Features: ADX,AESNI,AVX,AVX2,BMI1,BMI2,CLMUL,CLZERO,CMOV,CMPXCHG8,CPBOOST,CX16,F16C,FMA3,FXSR,FXSROPT,HTT,HYPERVISOR,LAHF,LZCNT,MCAOVERFLOW,MMX,MMXEXT,MOVBE,NX,OSXSAVE,POPCNT,RDRAND,RDSEED,RDTSCP,SCE,SHA,SSE,SSE2,SSE3,SSE4,SSE42,SSE4A,SSSE3,SUCCOR,X87,XSAVE
+Microarchitecture level: 3
+Cacheline bytes: 64
+L1 Instruction Cache: 32768 bytes
+L1 Data Cache: 32768 bytes
+L2 Cache: 524288 bytes
+L3 Cache: 16777216 bytes
+
+```
+### JSON Output:
+
+```
+λ cpuid --json
+{
+  "BrandName": "AMD Ryzen 9 3950X 16-Core Processor",
+  "VendorID": 2,
+  "VendorString": "AuthenticAMD",
+  "PhysicalCores": 16,
+  "ThreadsPerCore": 2,
+  "LogicalCores": 32,
+  "Family": 23,
+  "Model": 113,
+  "CacheLine": 64,
+  "Hz": 0,
+  "BoostFreq": 0,
+  "Cache": {
+    "L1I": 32768,
+    "L1D": 32768,
+    "L2": 524288,
+    "L3": 16777216
+  },
+  "SGX": {
+    "Available": false,
+    "LaunchControl": false,
+    "SGX1Supported": false,
+    "SGX2Supported": false,
+    "MaxEnclaveSizeNot64": 0,
+    "MaxEnclaveSize64": 0,
+    "EPCSections": null
+  },
+  "Features": [
+    "ADX",
+    "AESNI",
+    "AVX",
+    "AVX2",
+    "BMI1",
+    "BMI2",
+    "CLMUL",
+    "CLZERO",
+    "CMOV",
+    "CMPXCHG8",
+    "CPBOOST",
+    "CX16",
+    "F16C",
+    "FMA3",
+    "FXSR",
+    "FXSROPT",
+    "HTT",
+    "HYPERVISOR",
+    "LAHF",
+    "LZCNT",
+    "MCAOVERFLOW",
+    "MMX",
+    "MMXEXT",
+    "MOVBE",
+    "NX",
+    "OSXSAVE",
+    "POPCNT",
+    "RDRAND",
+    "RDSEED",
+    "RDTSCP",
+    "SCE",
+    "SHA",
+    "SSE",
+    "SSE2",
+    "SSE3",
+    "SSE4",
+    "SSE42",
+    "SSE4A",
+    "SSSE3",
+    "SUCCOR",
+    "X87",
+    "XSAVE"
+  ],
+  "X64Level": 3
+}
+```
+
+### Check CPU microarch level
+
+```
+λ cpuid --check-level=3
+2022/03/18 17:04:40 AMD Ryzen 9 3950X 16-Core Processor
+2022/03/18 17:04:40 Microarchitecture level 3 is supported. Max level is 3.
+Exit Code 0
+
+λ cpuid --check-level=4
+2022/03/18 17:06:18 AMD Ryzen 9 3950X 16-Core Processor
+2022/03/18 17:06:18 Microarchitecture level 4 not supported. Max level is 3.
+Exit Code 1
+```
+
+
+## Available flags
+
+### x86 & amd64 
+
+| Feature Flag       | Description                                                                                                                                                                        |
+|--------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| ADX                | Intel ADX (Multi-Precision Add-Carry Instruction Extensions)                                                                                                                       |
+| AESNI              | Advanced Encryption Standard New Instructions                                                                                                                                      |
+| AMD3DNOW           | AMD 3DNOW                                                                                                                                                                          |
+| AMD3DNOWEXT        | AMD 3DNowExt                                                                                                                                                                       |
+| AMXBF16            | Tile computational operations on BFLOAT16 numbers                                                                                                                                  |
+| AMXINT8            | Tile computational operations on 8-bit integers                                                                                                                                    |
+| AMXFP16            | Tile computational operations on FP16 numbers                                                                                                                                      |
+| AMXTILE            | Tile architecture                                                                                                                                                                  |
+| APX_F              | Intel APX                                                                                                                                                                          |
+| AVX                | AVX functions                                                                                                                                                                      |
+| AVX10              | If set the Intel AVX10 Converged Vector ISA is supported                                                                                                                           |
+| AVX10_128          | If set indicates that AVX10 128-bit vector support is present                                                                                                                      |
+| AVX10_256          | If set indicates that AVX10 256-bit vector support is present                                                                                                                      |
+| AVX10_512          | If set indicates that AVX10 512-bit vector support is present                                                                                                                      |
+| AVX2               | AVX2 functions                                                                                                                                                                     |
+| AVX512BF16         | AVX-512 BFLOAT16 Instructions                                                                                                                                                      |
+| AVX512BITALG       | AVX-512 Bit Algorithms                                                                                                                                                             |
+| AVX512BW           | AVX-512 Byte and Word Instructions                                                                                                                                                 |
+| AVX512CD           | AVX-512 Conflict Detection Instructions                                                                                                                                            |
+| AVX512DQ           | AVX-512 Doubleword and Quadword Instructions                                                                                                                                       |
+| AVX512ER           | AVX-512 Exponential and Reciprocal Instructions                                                                                                                                    |
+| AVX512F            | AVX-512 Foundation                                                                                                                                                                 |
+| AVX512FP16         | AVX-512 FP16 Instructions                                                                                                                                                          |
+| AVX512IFMA         | AVX-512 Integer Fused Multiply-Add Instructions                                                                                                                                    |
+| AVX512PF           | AVX-512 Prefetch Instructions                                                                                                                                                      |
+| AVX512VBMI         | AVX-512 Vector Bit Manipulation Instructions                                                                                                                                       |
+| AVX512VBMI2        | AVX-512 Vector Bit Manipulation Instructions, Version 2                                                                                                                            |
+| AVX512VL           | AVX-512 Vector Length Extensions                                                                                                                                                   |
+| AVX512VNNI         | AVX-512 Vector Neural Network Instructions                                                                                                                                         |
+| AVX512VP2INTERSECT | AVX-512 Intersect for D/Q                                                                                                                                                          |
+| AVX512VPOPCNTDQ    | AVX-512 Vector Population Count Doubleword and Quadword                                                                                                                            |
+| AVXIFMA            | AVX-IFMA instructions                                                                                                                                                              |
+| AVXNECONVERT       | AVX-NE-CONVERT instructions                                                                                                                                                        |
+| AVXSLOW            | Indicates the CPU performs 2 128 bit operations instead of one                                                                                                                     |
+| AVXVNNI            | AVX (VEX encoded) VNNI neural network instructions                                                                                                                                 |
+| AVXVNNIINT8        | AVX-VNNI-INT8 instructions                                                                                                                                                         |
+| BHI_CTRL           | Branch History Injection and Intra-mode Branch Target Injection / CVE-2022-0001, CVE-2022-0002 / INTEL-SA-00598                                                                    |
+| BMI1               | Bit Manipulation Instruction Set 1                                                                                                                                                 |
+| BMI2               | Bit Manipulation Instruction Set 2                                                                                                                                                 |
+| CETIBT             | Intel CET Indirect Branch Tracking                                                                                                                                                 |
+| CETSS              | Intel CET Shadow Stack                                                                                                                                                             |
+| CLDEMOTE           | Cache Line Demote                                                                                                                                                                  |
+| CLMUL              | Carry-less Multiplication                                                                                                                                                          |
+| CLZERO             | CLZERO instruction supported                                                                                                                                                       |
+| CMOV               | i686 CMOV                                                                                                                                                                          |
+| CMPCCXADD          | CMPCCXADD instructions                                                                                                                                                             |
+| CMPSB_SCADBS_SHORT | Fast short CMPSB and SCASB                                                                                                                                                         |
+| CMPXCHG8           | CMPXCHG8 instruction                                                                                                                                                               |
+| CPBOOST            | Core Performance Boost                                                                                                                                                             |
+| CPPC               | AMD: Collaborative Processor Performance Control                                                                                                                                   |
+| CX16               | CMPXCHG16B Instruction                                                                                                                                                             |
+| EFER_LMSLE_UNS     | AMD: =Core::X86::Msr::EFER[LMSLE] is not supported, and MBZ                                                                                                                        |
+| ENQCMD             | Enqueue Command                                                                                                                                                                    |
+| ERMS               | Enhanced REP MOVSB/STOSB                                                                                                                                                           |
+| F16C               | Half-precision floating-point conversion                                                                                                                                           |
+| FLUSH_L1D          | Flush L1D cache                                                                                                                                                                    |
+| FMA3               | Intel FMA 3. Does not imply AVX.                                                                                                                                                   |
+| FMA4               | Bulldozer FMA4 functions                                                                                                                                                           |
+| FP128              | AMD: When set, the internal FP/SIMD execution datapath is 128-bits wide                                                                                                            |
+| FP256              | AMD: When set, the internal FP/SIMD execution datapath is 256-bits wide                                                                                                            |
+| FSRM               | Fast Short Rep Mov                                                                                                                                                                 |
+| FXSR               | FXSAVE, FXRESTOR instructions, CR4 bit 9                                                                                                                                           |
+| FXSROPT            | FXSAVE/FXRSTOR optimizations                                                                                                                                                       |
+| GFNI               | Galois Field New Instructions. May require other features (AVX, AVX512VL,AVX512F) based on usage.                                                                                  |
+| HLE                | Hardware Lock Elision                                                                                                                                                              |
+| HRESET             | If set CPU supports history reset and the IA32_HRESET_ENABLE MSR                                                                                                                   |
+| HTT                | Hyperthreading (enabled)                                                                                                                                                           |
+| HWA                | Hardware assert supported. Indicates support for MSRC001_10                                                                                                                        |
+| HYBRID_CPU         | This part has CPUs of more than one type.                                                                                                                                          |
+| HYPERVISOR         | This bit has been reserved by Intel & AMD for use by hypervisors                                                                                                                   |
+| IA32_ARCH_CAP      | IA32_ARCH_CAPABILITIES MSR (Intel)                                                                                                                                                 |
+| IA32_CORE_CAP      | IA32_CORE_CAPABILITIES MSR                                                                                                                                                         |
+| IBPB               | Indirect Branch Restricted Speculation (IBRS) and Indirect Branch Predictor Barrier (IBPB)                                                                                         |
+| IBRS               | AMD: Indirect Branch Restricted Speculation                                                                                                                                        |
+| IBRS_PREFERRED     | AMD: IBRS is preferred over software solution                                                                                                                                      |
+| IBRS_PROVIDES_SMP  | AMD: IBRS provides Same Mode Protection                                                                                                                                            |
+| IBS                | Instruction Based Sampling (AMD)                                                                                                                                                   |
+| IBSBRNTRGT         | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
+| IBSFETCHSAM        | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
+| IBSFFV             | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
+| IBSOPCNT           | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
+| IBSOPCNTEXT        | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
+| IBSOPSAM           | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
+| IBSRDWROPCNT       | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
+| IBSRIPINVALIDCHK   | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
+| IBS_FETCH_CTLX     | AMD: IBS fetch control extended MSR supported                                                                                                                                      |
+| IBS_OPDATA4        | AMD: IBS op data 4 MSR supported                                                                                                                                                   |
+| IBS_OPFUSE         | AMD: Indicates support for IbsOpFuse                                                                                                                                               |
+| IBS_PREVENTHOST    | Disallowing IBS use by the host supported                                                                                                                                          |
+| IBS_ZEN4           | Fetch and Op IBS support IBS extensions added with Zen4                                                                                                                            |
+| IDPRED_CTRL        | IPRED_DIS                                                                                                                                                                          |
+| INT_WBINVD         | WBINVD/WBNOINVD are interruptible.                                                                                                                                                 |
+| INVLPGB            | NVLPGB and TLBSYNC instruction supported                                                                                                                                           |
+| KEYLOCKER          | Key locker                                                                                                                                                                         |
+| KEYLOCKERW         | Key locker wide                                                                                                                                                                    |
+| LAHF               | LAHF/SAHF in long mode                                                                                                                                                             |
+| LAM                | If set, CPU supports Linear Address Masking                                                                                                                                        |
+| LBRVIRT            | LBR virtualization                                                                                                                                                                 |
+| LZCNT              | LZCNT instruction                                                                                                                                                                  |
+| MCAOVERFLOW        | MCA overflow recovery support.                                                                                                                                                     |
+| MCDT_NO            | Processor do not exhibit MXCSR Configuration Dependent Timing behavior and do not need to mitigate it.                                                                             |
+| MCOMMIT            | MCOMMIT instruction supported                                                                                                                                                      |
+| MD_CLEAR           | VERW clears CPU buffers                                                                                                                                                            |
+| MMX                | standard MMX                                                                                                                                                                       |
+| MMXEXT             | SSE integer functions or AMD MMX ext                                                                                                                                               |
+| MOVBE              | MOVBE instruction (big-endian)                                                                                                                                                     |
+| MOVDIR64B          | Move 64 Bytes as Direct Store                                                                                                                                                      |
+| MOVDIRI            | Move Doubleword as Direct Store                                                                                                                                                    |
+| MOVSB_ZL           | Fast Zero-Length MOVSB                                                                                                                                                             |
+| MPX                | Intel MPX (Memory Protection Extensions)                                                                                                                                           |
+| MOVU               | MOVU SSE instructions are more efficient and should be preferred to SSE  MOVL/MOVH. MOVUPS is more efficient than MOVLPS/MOVHPS. MOVUPD is more efficient than MOVLPD/MOVHPD        |
+| MSRIRC             | Instruction Retired Counter MSR available                                                                                                                                          |
+| MSRLIST            | Read/Write List of Model Specific Registers                                                                                                                                        |
+| MSR_PAGEFLUSH      | Page Flush MSR available                                                                                                                                                           |
+| NRIPS              | Indicates support for NRIP save on VMEXIT                                                                                                                                          |
+| NX                 | NX (No-Execute) bit                                                                                                                                                                |
+| OSXSAVE            | XSAVE enabled by OS                                                                                                                                                                |
+| PCONFIG            | PCONFIG for Intel Multi-Key Total Memory Encryption                                                                                                                                |
+| POPCNT             | POPCNT instruction                                                                                                                                                                 |
+| PPIN               | AMD: Protected Processor Inventory Number support. Indicates that Protected Processor Inventory Number (PPIN) capability can be enabled                                            |
+| PREFETCHI          | PREFETCHIT0/1 instructions                                                                                                                                                         |
+| PSFD               | Predictive Store Forward Disable                                                                                                                                                   |
+| RDPRU              | RDPRU instruction supported                                                                                                                                                        |
+| RDRAND             | RDRAND instruction is available                                                                                                                                                    |
+| RDSEED             | RDSEED instruction is available                                                                                                                                                    |
+| RDTSCP             | RDTSCP Instruction                                                                                                                                                                 |
+| RRSBA_CTRL         | Restricted RSB Alternate                                                                                                                                                           |
+| RTM                | Restricted Transactional Memory                                                                                                                                                    |
+| RTM_ALWAYS_ABORT   | Indicates that the loaded microcode is forcing RTM abort.                                                                                                                          |
+| SERIALIZE          | Serialize Instruction Execution                                                                                                                                                    |
+| SEV                | AMD Secure Encrypted Virtualization supported                                                                                                                                      |
+| SEV_64BIT          | AMD SEV guest execution only allowed from a 64-bit host                                                                                                                            |
+| SEV_ALTERNATIVE    | AMD SEV Alternate Injection supported                                                                                                                                              |
+| SEV_DEBUGSWAP      | Full debug state swap supported for SEV-ES guests                                                                                                                                  |
+| SEV_ES             | AMD SEV Encrypted State supported                                                                                                                                                  |
+| SEV_RESTRICTED     | AMD SEV Restricted Injection supported                                                                                                                                             |
+| SEV_SNP            | AMD SEV Secure Nested Paging supported                                                                                                                                             |
+| SGX                | Software Guard Extensions                                                                                                                                                          |
+| SGXLC              | Software Guard Extensions Launch Control                                                                                                                                           |
+| SHA                | Intel SHA Extensions                                                                                                                                                               |
+| SME                | AMD Secure Memory Encryption supported                                                                                                                                             |
+| SME_COHERENT       | AMD Hardware cache coherency across encryption domains enforced                                                                                                                    |
+| SPEC_CTRL_SSBD     | Speculative Store Bypass Disable                                                                                                                                                   |
+| SRBDS_CTRL         | SRBDS mitigation MSR available                                                                                                                                                     |
+| SSE                | SSE functions                                                                                                                                                                      |
+| SSE2               | P4 SSE functions                                                                                                                                                                   |
+| SSE3               | Prescott SSE3 functions                                                                                                                                                            |
+| SSE4               | Penryn SSE4.1 functions                                                                                                                                                            |
+| SSE42              | Nehalem SSE4.2 functions                                                                                                                                                           |
+| SSE4A              | AMD Barcelona microarchitecture SSE4a instructions                                                                                                                                 |
+| SSSE3              | Conroe SSSE3 functions                                                                                                                                                             |
+| STIBP              | Single Thread Indirect Branch Predictors                                                                                                                                           |
+| STIBP_ALWAYSON     | AMD: Single Thread Indirect Branch Prediction Mode has Enhanced Performance and may be left Always On                                                                              |
+| STOSB_SHORT        | Fast short STOSB                                                                                                                                                                   |
+| SUCCOR             | Software uncorrectable error containment and recovery capability.                                                                                                                  |
+| SVM                | AMD Secure Virtual Machine                                                                                                                                                         |
+| SVMDA              | Indicates support for the SVM decode assists.                                                                                                                                      |
+| SVMFBASID          | SVM, Indicates that TLB flush events, including CR3 writes and CR4.PGE toggles, flush only the current ASID's TLB entries. Also indicates support for the extended VMCBTLB_Control |
+| SVML               | AMD SVM lock. Indicates support for SVM-Lock.                                                                                                                                      |
+| SVMNP              | AMD SVM nested paging                                                                                                                                                              |
+| SVMPF              | SVM pause intercept filter. Indicates support for the pause intercept filter                                                                                                       |
+| SVMPFT             | SVM PAUSE filter threshold. Indicates support for the PAUSE filter cycle count threshold                                                                                           |
+| SYSCALL            | System-Call Extension (SCE): SYSCALL and SYSRET instructions.                                                                                                                      |
+| SYSEE              | SYSENTER and SYSEXIT instructions                                                                                                                                                  |
+| TBM                | AMD Trailing Bit Manipulation                                                                                                                                                      |
+| TDX_GUEST          | Intel Trust Domain Extensions Guest                                                                                                                                                |
+| TLB_FLUSH_NESTED   | AMD: Flushing includes all the nested translations for guest translations                                                                                                          |
+| TME                | Intel Total Memory Encryption. The following MSRs are supported: IA32_TME_CAPABILITY, IA32_TME_ACTIVATE, IA32_TME_EXCLUDE_MASK, and IA32_TME_EXCLUDE_BASE.                         |
+| TOPEXT             | TopologyExtensions: topology extensions support. Indicates support for CPUID Fn8000_001D_EAX_x[N:0]-CPUID Fn8000_001E_EDX.                                                         |
+| TSCRATEMSR         | MSR based TSC rate control. Indicates support for MSR TSC ratio MSRC000_0104                                                                                                       |
+| TSXLDTRK           | Intel TSX Suspend Load Address Tracking                                                                                                                                            |
+| VAES               | Vector AES. AVX(512) versions requires additional checks.                                                                                                                          |
+| VMCBCLEAN          | VMCB clean bits. Indicates support for VMCB clean bits.                                                                                                                            |
+| VMPL               | AMD VM Permission Levels supported                                                                                                                                                 |
+| VMSA_REGPROT       | AMD VMSA Register Protection supported                                                                                                                                             |
+| VMX                | Virtual Machine Extensions                                                                                                                                                         |
+| VPCLMULQDQ         | Carry-Less Multiplication Quadword. Requires AVX for 3 register versions.                                                                                                          |
+| VTE                | AMD Virtual Transparent Encryption supported                                                                                                                                       |
+| WAITPKG            | TPAUSE, UMONITOR, UMWAIT                                                                                                                                                           |
+| WBNOINVD           | Write Back and Do Not Invalidate Cache                                                                                                                                             |
+| WRMSRNS            | Non-Serializing Write to Model Specific Register                                                                                                                                   |
+| X87                | FPU                                                                                                                                                                                |
+| XGETBV1            | Supports XGETBV with ECX = 1                                                                                                                                                       |
+| XOP                | Bulldozer XOP functions                                                                                                                                                            |
+| XSAVE              | XSAVE, XRESTOR, XSETBV, XGETBV                                                                                                                                                     |
+| XSAVEC             | Supports XSAVEC and the compacted form of XRSTOR.                                                                                                                                  |
+| XSAVEOPT           | XSAVEOPT available                                                                                                                                                                 |
+| XSAVES             | Supports XSAVES/XRSTORS and IA32_XSS                                                                                                                                               |
+
+# ARM features:
+
+| Feature Flag | Description                                                      |
+|--------------|------------------------------------------------------------------|
+| AESARM       | AES instructions                                                 |
+| ARMCPUID     | Some CPU ID registers readable at user-level                     |
+| ASIMD        | Advanced SIMD                                                    |
+| ASIMDDP      | SIMD Dot Product                                                 |
+| ASIMDHP      | Advanced SIMD half-precision floating point                      |
+| ASIMDRDM     | Rounding Double Multiply Accumulate/Subtract (SQRDMLAH/SQRDMLSH) |
+| ATOMICS      | Large System Extensions (LSE)                                    |
+| CRC32        | CRC32/CRC32C instructions                                        |
+| DCPOP        | Data cache clean to Point of Persistence (DC CVAP)               |
+| EVTSTRM      | Generic timer                                                    |
+| FCMA         | Floatin point complex number addition and multiplication         |
+| FP           | Single-precision and double-precision floating point             |
+| FPHP         | Half-precision floating point                                    |
+| GPA          | Generic Pointer Authentication                                   |
+| JSCVT        | Javascript-style double->int convert (FJCVTZS)                   |
+| LRCPC        | Weaker release consistency (LDAPR, etc)                          |
+| PMULL        | Polynomial Multiply instructions (PMULL/PMULL2)                  |
+| SHA1         | SHA-1 instructions (SHA1C, etc)                                  |
+| SHA2         | SHA-2 instructions (SHA256H, etc)                                |
+| SHA3         | SHA-3 instructions (EOR3, RAXI, XAR, BCAX)                       |
+| SHA512       | SHA512 instructions                                              |
+| SM3          | SM3 instructions                                                 |
+| SM4          | SM4 instructions                                                 |
+| SVE          | Scalable Vector Extension                                        |
+
+# license
+
+This code is published under an MIT license. See LICENSE file for more information.
diff --git a/vendor/github.com/klauspost/cpuid/v2/cpuid.go b/vendor/github.com/klauspost/cpuid/v2/cpuid.go
new file mode 100644
index 0000000..15b7603
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/cpuid.go
@@ -0,0 +1,1473 @@
+// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
+
+// Package cpuid provides information about the CPU running the current program.
+//
+// CPU features are detected on startup, and kept for fast access through the life of the application.
+// Currently x86 / x64 (AMD64) as well as arm64 is supported.
+//
+// You can access the CPU information by accessing the shared CPU variable of the cpuid library.
+//
+// Package home: https://github.com/klauspost/cpuid
+package cpuid
+
+import (
+        "flag"
+        "fmt"
+        "math"
+        "math/bits"
+        "os"
+        "runtime"
+        "strings"
+)
+
+// AMD refererence: https://www.amd.com/system/files/TechDocs/25481.pdf
+// and Processor Programming Reference (PPR)
+
+// Vendor is a representation of a CPU vendor.
+type Vendor int
+
+const (
+        VendorUnknown Vendor = iota
+        Intel
+        AMD
+        VIA
+        Transmeta
+        NSC
+        KVM  // Kernel-based Virtual Machine
+        MSVM // Microsoft Hyper-V or Windows Virtual PC
+        VMware
+        XenHVM
+        Bhyve
+        Hygon
+        SiS
+        RDC
+
+        Ampere
+        ARM
+        Broadcom
+        Cavium
+        DEC
+        Fujitsu
+        Infineon
+        Motorola
+        NVIDIA
+        AMCC
+        Qualcomm
+        Marvell
+
+        lastVendor
+)
+
+//go:generate stringer -type=FeatureID,Vendor
+
+// FeatureID is the ID of a specific cpu feature.
+type FeatureID int
+
+const (
+        // Keep index -1 as unknown
+        UNKNOWN = -1
+
+        // Add features
+        ADX                FeatureID = iota // Intel ADX (Multi-Precision Add-Carry Instruction Extensions)
+        AESNI                               // Advanced Encryption Standard New Instructions
+        AMD3DNOW                            // AMD 3DNOW
+        AMD3DNOWEXT                         // AMD 3DNowExt
+        AMXBF16                             // Tile computational operations on BFLOAT16 numbers
+        AMXFP16                             // Tile computational operations on FP16 numbers
+        AMXINT8                             // Tile computational operations on 8-bit integers
+        AMXTILE                             // Tile architecture
+        APX_F                               // Intel APX
+        AVX                                 // AVX functions
+        AVX10                               // If set the Intel AVX10 Converged Vector ISA is supported
+        AVX10_128                           // If set indicates that AVX10 128-bit vector support is present
+        AVX10_256                           // If set indicates that AVX10 256-bit vector support is present
+        AVX10_512                           // If set indicates that AVX10 512-bit vector support is present
+        AVX2                                // AVX2 functions
+        AVX512BF16                          // AVX-512 BFLOAT16 Instructions
+        AVX512BITALG                        // AVX-512 Bit Algorithms
+        AVX512BW                            // AVX-512 Byte and Word Instructions
+        AVX512CD                            // AVX-512 Conflict Detection Instructions
+        AVX512DQ                            // AVX-512 Doubleword and Quadword Instructions
+        AVX512ER                            // AVX-512 Exponential and Reciprocal Instructions
+        AVX512F                             // AVX-512 Foundation
+        AVX512FP16                          // AVX-512 FP16 Instructions
+        AVX512IFMA                          // AVX-512 Integer Fused Multiply-Add Instructions
+        AVX512PF                            // AVX-512 Prefetch Instructions
+        AVX512VBMI                          // AVX-512 Vector Bit Manipulation Instructions
+        AVX512VBMI2                         // AVX-512 Vector Bit Manipulation Instructions, Version 2
+        AVX512VL                            // AVX-512 Vector Length Extensions
+        AVX512VNNI                          // AVX-512 Vector Neural Network Instructions
+        AVX512VP2INTERSECT                  // AVX-512 Intersect for D/Q
+        AVX512VPOPCNTDQ                     // AVX-512 Vector Population Count Doubleword and Quadword
+        AVXIFMA                             // AVX-IFMA instructions
+        AVXNECONVERT                        // AVX-NE-CONVERT instructions
+        AVXSLOW                             // Indicates the CPU performs 2 128 bit operations instead of one
+        AVXVNNI                             // AVX (VEX encoded) VNNI neural network instructions
+        AVXVNNIINT8                         // AVX-VNNI-INT8 instructions
+        BHI_CTRL                            // Branch History Injection and Intra-mode Branch Target Injection / CVE-2022-0001, CVE-2022-0002 / INTEL-SA-00598
+        BMI1                                // Bit Manipulation Instruction Set 1
+        BMI2                                // Bit Manipulation Instruction Set 2
+        CETIBT                              // Intel CET Indirect Branch Tracking
+        CETSS                               // Intel CET Shadow Stack
+        CLDEMOTE                            // Cache Line Demote
+        CLMUL                               // Carry-less Multiplication
+        CLZERO                              // CLZERO instruction supported
+        CMOV                                // i686 CMOV
+        CMPCCXADD                           // CMPCCXADD instructions
+        CMPSB_SCADBS_SHORT                  // Fast short CMPSB and SCASB
+        CMPXCHG8                            // CMPXCHG8 instruction
+        CPBOOST                             // Core Performance Boost
+        CPPC                                // AMD: Collaborative Processor Performance Control
+        CX16                                // CMPXCHG16B Instruction
+        EFER_LMSLE_UNS                      // AMD: =Core::X86::Msr::EFER[LMSLE] is not supported, and MBZ
+        ENQCMD                              // Enqueue Command
+        ERMS                                // Enhanced REP MOVSB/STOSB
+        F16C                                // Half-precision floating-point conversion
+        FLUSH_L1D                           // Flush L1D cache
+        FMA3                                // Intel FMA 3. Does not imply AVX.
+        FMA4                                // Bulldozer FMA4 functions
+        FP128                               // AMD: When set, the internal FP/SIMD execution datapath is no more than 128-bits wide
+        FP256                               // AMD: When set, the internal FP/SIMD execution datapath is no more than 256-bits wide
+        FSRM                                // Fast Short Rep Mov
+        FXSR                                // FXSAVE, FXRESTOR instructions, CR4 bit 9
+        FXSROPT                             // FXSAVE/FXRSTOR optimizations
+        GFNI                                // Galois Field New Instructions. May require other features (AVX, AVX512VL,AVX512F) based on usage.
+        HLE                                 // Hardware Lock Elision
+        HRESET                              // If set CPU supports history reset and the IA32_HRESET_ENABLE MSR
+        HTT                                 // Hyperthreading (enabled)
+        HWA                                 // Hardware assert supported. Indicates support for MSRC001_10
+        HYBRID_CPU                          // This part has CPUs of more than one type.
+        HYPERVISOR                          // This bit has been reserved by Intel & AMD for use by hypervisors
+        IA32_ARCH_CAP                       // IA32_ARCH_CAPABILITIES MSR (Intel)
+        IA32_CORE_CAP                       // IA32_CORE_CAPABILITIES MSR
+        IBPB                                // Indirect Branch Restricted Speculation (IBRS) and Indirect Branch Predictor Barrier (IBPB)
+        IBRS                                // AMD: Indirect Branch Restricted Speculation
+        IBRS_PREFERRED                      // AMD: IBRS is preferred over software solution
+        IBRS_PROVIDES_SMP                   // AMD: IBRS provides Same Mode Protection
+        IBS                                 // Instruction Based Sampling (AMD)
+        IBSBRNTRGT                          // Instruction Based Sampling Feature (AMD)
+        IBSFETCHSAM                         // Instruction Based Sampling Feature (AMD)
+        IBSFFV                              // Instruction Based Sampling Feature (AMD)
+        IBSOPCNT                            // Instruction Based Sampling Feature (AMD)
+        IBSOPCNTEXT                         // Instruction Based Sampling Feature (AMD)
+        IBSOPSAM                            // Instruction Based Sampling Feature (AMD)
+        IBSRDWROPCNT                        // Instruction Based Sampling Feature (AMD)
+        IBSRIPINVALIDCHK                    // Instruction Based Sampling Feature (AMD)
+        IBS_FETCH_CTLX                      // AMD: IBS fetch control extended MSR supported
+        IBS_OPDATA4                         // AMD: IBS op data 4 MSR supported
+        IBS_OPFUSE                          // AMD: Indicates support for IbsOpFuse
+        IBS_PREVENTHOST                     // Disallowing IBS use by the host supported
+        IBS_ZEN4                            // AMD: Fetch and Op IBS support IBS extensions added with Zen4
+        IDPRED_CTRL                         // IPRED_DIS
+        INT_WBINVD                          // WBINVD/WBNOINVD are interruptible.
+        INVLPGB                             // NVLPGB and TLBSYNC instruction supported
+        KEYLOCKER                           // Key locker
+        KEYLOCKERW                          // Key locker wide
+        LAHF                                // LAHF/SAHF in long mode
+        LAM                                 // If set, CPU supports Linear Address Masking
+        LBRVIRT                             // LBR virtualization
+        LZCNT                               // LZCNT instruction
+        MCAOVERFLOW                         // MCA overflow recovery support.
+        MCDT_NO                             // Processor do not exhibit MXCSR Configuration Dependent Timing behavior and do not need to mitigate it.
+        MCOMMIT                             // MCOMMIT instruction supported
+        MD_CLEAR                            // VERW clears CPU buffers
+        MMX                                 // standard MMX
+        MMXEXT                              // SSE integer functions or AMD MMX ext
+        MOVBE                               // MOVBE instruction (big-endian)
+        MOVDIR64B                           // Move 64 Bytes as Direct Store
+        MOVDIRI                             // Move Doubleword as Direct Store
+        MOVSB_ZL                            // Fast Zero-Length MOVSB
+        MOVU                                // AMD: MOVU SSE instructions are more efficient and should be preferred to SSE     MOVL/MOVH. MOVUPS is more efficient than MOVLPS/MOVHPS. MOVUPD is more efficient than MOVLPD/MOVHPD
+        MPX                                 // Intel MPX (Memory Protection Extensions)
+        MSRIRC                              // Instruction Retired Counter MSR available
+        MSRLIST                             // Read/Write List of Model Specific Registers
+        MSR_PAGEFLUSH                       // Page Flush MSR available
+        NRIPS                               // Indicates support for NRIP save on VMEXIT
+        NX                                  // NX (No-Execute) bit
+        OSXSAVE                             // XSAVE enabled by OS
+        PCONFIG                             // PCONFIG for Intel Multi-Key Total Memory Encryption
+        POPCNT                              // POPCNT instruction
+        PPIN                                // AMD: Protected Processor Inventory Number support. Indicates that Protected Processor Inventory Number (PPIN) capability can be enabled
+        PREFETCHI                           // PREFETCHIT0/1 instructions
+        PSFD                                // Predictive Store Forward Disable
+        RDPRU                               // RDPRU instruction supported
+        RDRAND                              // RDRAND instruction is available
+        RDSEED                              // RDSEED instruction is available
+        RDTSCP                              // RDTSCP Instruction
+        RRSBA_CTRL                          // Restricted RSB Alternate
+        RTM                                 // Restricted Transactional Memory
+        RTM_ALWAYS_ABORT                    // Indicates that the loaded microcode is forcing RTM abort.
+        SERIALIZE                           // Serialize Instruction Execution
+        SEV                                 // AMD Secure Encrypted Virtualization supported
+        SEV_64BIT                           // AMD SEV guest execution only allowed from a 64-bit host
+        SEV_ALTERNATIVE                     // AMD SEV Alternate Injection supported
+        SEV_DEBUGSWAP                       // Full debug state swap supported for SEV-ES guests
+        SEV_ES                              // AMD SEV Encrypted State supported
+        SEV_RESTRICTED                      // AMD SEV Restricted Injection supported
+        SEV_SNP                             // AMD SEV Secure Nested Paging supported
+        SGX                                 // Software Guard Extensions
+        SGXLC                               // Software Guard Extensions Launch Control
+        SHA                                 // Intel SHA Extensions
+        SME                                 // AMD Secure Memory Encryption supported
+        SME_COHERENT                        // AMD Hardware cache coherency across encryption domains enforced
+        SPEC_CTRL_SSBD                      // Speculative Store Bypass Disable
+        SRBDS_CTRL                          // SRBDS mitigation MSR available
+        SSE                                 // SSE functions
+        SSE2                                // P4 SSE functions
+        SSE3                                // Prescott SSE3 functions
+        SSE4                                // Penryn SSE4.1 functions
+        SSE42                               // Nehalem SSE4.2 functions
+        SSE4A                               // AMD Barcelona microarchitecture SSE4a instructions
+        SSSE3                               // Conroe SSSE3 functions
+        STIBP                               // Single Thread Indirect Branch Predictors
+        STIBP_ALWAYSON                      // AMD: Single Thread Indirect Branch Prediction Mode has Enhanced Performance and may be left Always On
+        STOSB_SHORT                         // Fast short STOSB
+        SUCCOR                              // Software uncorrectable error containment and recovery capability.
+        SVM                                 // AMD Secure Virtual Machine
+        SVMDA                               // Indicates support for the SVM decode assists.
+        SVMFBASID                           // SVM, Indicates that TLB flush events, including CR3 writes and CR4.PGE toggles, flush only the current ASID's TLB entries. Also indicates support for the extended VMCBTLB_Control
+        SVML                                // AMD SVM lock. Indicates support for SVM-Lock.
+        SVMNP                               // AMD SVM nested paging
+        SVMPF                               // SVM pause intercept filter. Indicates support for the pause intercept filter
+        SVMPFT                              // SVM PAUSE filter threshold. Indicates support for the PAUSE filter cycle count threshold
+        SYSCALL                             // System-Call Extension (SCE): SYSCALL and SYSRET instructions.
+        SYSEE                               // SYSENTER and SYSEXIT instructions
+        TBM                                 // AMD Trailing Bit Manipulation
+        TDX_GUEST                           // Intel Trust Domain Extensions Guest
+        TLB_FLUSH_NESTED                    // AMD: Flushing includes all the nested translations for guest translations
+        TME                                 // Intel Total Memory Encryption. The following MSRs are supported: IA32_TME_CAPABILITY, IA32_TME_ACTIVATE, IA32_TME_EXCLUDE_MASK, and IA32_TME_EXCLUDE_BASE.
+        TOPEXT                              // TopologyExtensions: topology extensions support. Indicates support for CPUID Fn8000_001D_EAX_x[N:0]-CPUID Fn8000_001E_EDX.
+        TSCRATEMSR                          // MSR based TSC rate control. Indicates support for MSR TSC ratio MSRC000_0104
+        TSXLDTRK                            // Intel TSX Suspend Load Address Tracking
+        VAES                                // Vector AES. AVX(512) versions requires additional checks.
+        VMCBCLEAN                           // VMCB clean bits. Indicates support for VMCB clean bits.
+        VMPL                                // AMD VM Permission Levels supported
+        VMSA_REGPROT                        // AMD VMSA Register Protection supported
+        VMX                                 // Virtual Machine Extensions
+        VPCLMULQDQ                          // Carry-Less Multiplication Quadword. Requires AVX for 3 register versions.
+        VTE                                 // AMD Virtual Transparent Encryption supported
+        WAITPKG                             // TPAUSE, UMONITOR, UMWAIT
+        WBNOINVD                            // Write Back and Do Not Invalidate Cache
+        WRMSRNS                             // Non-Serializing Write to Model Specific Register
+        X87                                 // FPU
+        XGETBV1                             // Supports XGETBV with ECX = 1
+        XOP                                 // Bulldozer XOP functions
+        XSAVE                               // XSAVE, XRESTOR, XSETBV, XGETBV
+        XSAVEC                              // Supports XSAVEC and the compacted form of XRSTOR.
+        XSAVEOPT                            // XSAVEOPT available
+        XSAVES                              // Supports XSAVES/XRSTORS and IA32_XSS
+
+        // ARM features:
+        AESARM   // AES instructions
+        ARMCPUID // Some CPU ID registers readable at user-level
+        ASIMD    // Advanced SIMD
+        ASIMDDP  // SIMD Dot Product
+        ASIMDHP  // Advanced SIMD half-precision floating point
+        ASIMDRDM // Rounding Double Multiply Accumulate/Subtract (SQRDMLAH/SQRDMLSH)
+        ATOMICS  // Large System Extensions (LSE)
+        CRC32    // CRC32/CRC32C instructions
+        DCPOP    // Data cache clean to Point of Persistence (DC CVAP)
+        EVTSTRM  // Generic timer
+        FCMA     // Floatin point complex number addition and multiplication
+        FP       // Single-precision and double-precision floating point
+        FPHP     // Half-precision floating point
+        GPA      // Generic Pointer Authentication
+        JSCVT    // Javascript-style double->int convert (FJCVTZS)
+        LRCPC    // Weaker release consistency (LDAPR, etc)
+        PMULL    // Polynomial Multiply instructions (PMULL/PMULL2)
+        SHA1     // SHA-1 instructions (SHA1C, etc)
+        SHA2     // SHA-2 instructions (SHA256H, etc)
+        SHA3     // SHA-3 instructions (EOR3, RAXI, XAR, BCAX)
+        SHA512   // SHA512 instructions
+        SM3      // SM3 instructions
+        SM4      // SM4 instructions
+        SVE      // Scalable Vector Extension
+        // Keep it last. It automatically defines the size of []flagSet
+        lastID
+
+        firstID FeatureID = UNKNOWN + 1
+)
+
+// CPUInfo contains information about the detected system CPU.
+type CPUInfo struct {
+        BrandName      string  // Brand name reported by the CPU
+        VendorID       Vendor  // Comparable CPU vendor ID
+        VendorString   string  // Raw vendor string.
+        featureSet     flagSet // Features of the CPU
+        PhysicalCores  int     // Number of physical processor cores in your CPU. Will be 0 if undetectable.
+        ThreadsPerCore int     // Number of threads per physical core. Will be 1 if undetectable.
+        LogicalCores   int     // Number of physical cores times threads that can run on each core through the use of hyperthreading. Will be 0 if undetectable.
+        Family         int     // CPU family number
+        Model          int     // CPU model number
+        Stepping       int     // CPU stepping info
+        CacheLine      int     // Cache line size in bytes. Will be 0 if undetectable.
+        Hz             int64   // Clock speed, if known, 0 otherwise. Will attempt to contain base clock speed.
+        BoostFreq      int64   // Max clock speed, if known, 0 otherwise
+        Cache          struct {
+                L1I int // L1 Instruction Cache (per core or shared). Will be -1 if undetected
+                L1D int // L1 Data Cache (per core or shared). Will be -1 if undetected
+                L2  int // L2 Cache (per core or shared). Will be -1 if undetected
+                L3  int // L3 Cache (per core, per ccx or shared). Will be -1 if undetected
+        }
+        SGX        SGXSupport
+        AVX10Level uint8
+        maxFunc    uint32
+        maxExFunc  uint32
+}
+
+var cpuid func(op uint32) (eax, ebx, ecx, edx uint32)
+var cpuidex func(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+var xgetbv func(index uint32) (eax, edx uint32)
+var rdtscpAsm func() (eax, ebx, ecx, edx uint32)
+var darwinHasAVX512 = func() bool { return false }
+
+// CPU contains information about the CPU as detected on startup,
+// or when Detect last was called.
+//
+// Use this as the primary entry point to you data.
+var CPU CPUInfo
+
+func init() {
+        initCPU()
+        Detect()
+}
+
+// Detect will re-detect current CPU info.
+// This will replace the content of the exported CPU variable.
+//
+// Unless you expect the CPU to change while you are running your program
+// you should not need to call this function.
+// If you call this, you must ensure that no other goroutine is accessing the
+// exported CPU variable.
+func Detect() {
+        // Set defaults
+        CPU.ThreadsPerCore = 1
+        CPU.Cache.L1I = -1
+        CPU.Cache.L1D = -1
+        CPU.Cache.L2 = -1
+        CPU.Cache.L3 = -1
+        safe := true
+        if detectArmFlag != nil {
+                safe = !*detectArmFlag
+        }
+        addInfo(&CPU, safe)
+        if displayFeats != nil && *displayFeats {
+                fmt.Println("cpu features:", strings.Join(CPU.FeatureSet(), ","))
+                // Exit with non-zero so tests will print value.
+                os.Exit(1)
+        }
+        if disableFlag != nil {
+                s := strings.Split(*disableFlag, ",")
+                for _, feat := range s {
+                        feat := ParseFeature(strings.TrimSpace(feat))
+                        if feat != UNKNOWN {
+                                CPU.featureSet.unset(feat)
+                        }
+                }
+        }
+}
+
+// DetectARM will detect ARM64 features.
+// This is NOT done automatically since it can potentially crash
+// if the OS does not handle the command.
+// If in the future this can be done safely this function may not
+// do anything.
+func DetectARM() {
+        addInfo(&CPU, false)
+}
+
+var detectArmFlag *bool
+var displayFeats *bool
+var disableFlag *string
+
+// Flags will enable flags.
+// This must be called *before* flag.Parse AND
+// Detect must be called after the flags have been parsed.
+// Note that this means that any detection used in init() functions
+// will not contain these flags.
+func Flags() {
+        disableFlag = flag.String("cpu.disable", "", "disable cpu features; comma separated list")
+        displayFeats = flag.Bool("cpu.features", false, "lists cpu features and exits")
+        detectArmFlag = flag.Bool("cpu.arm", false, "allow ARM features to be detected; can potentially crash")
+}
+
+// Supports returns whether the CPU supports all of the requested features.
+func (c CPUInfo) Supports(ids ...FeatureID) bool {
+        for _, id := range ids {
+                if !c.featureSet.inSet(id) {
+                        return false
+                }
+        }
+        return true
+}
+
+// Has allows for checking a single feature.
+// Should be inlined by the compiler.
+func (c *CPUInfo) Has(id FeatureID) bool {
+        return c.featureSet.inSet(id)
+}
+
+// AnyOf returns whether the CPU supports one or more of the requested features.
+func (c CPUInfo) AnyOf(ids ...FeatureID) bool {
+        for _, id := range ids {
+                if c.featureSet.inSet(id) {
+                        return true
+                }
+        }
+        return false
+}
+
+// Features contains several features combined for a fast check using
+// CpuInfo.HasAll
+type Features *flagSet
+
+// CombineFeatures allows to combine several features for a close to constant time lookup.
+func CombineFeatures(ids ...FeatureID) Features {
+        var v flagSet
+        for _, id := range ids {
+                v.set(id)
+        }
+        return &v
+}
+
+func (c *CPUInfo) HasAll(f Features) bool {
+        return c.featureSet.hasSetP(f)
+}
+
+// https://en.wikipedia.org/wiki/X86-64#Microarchitecture_levels
+var oneOfLevel = CombineFeatures(SYSEE, SYSCALL)
+var level1Features = CombineFeatures(CMOV, CMPXCHG8, X87, FXSR, MMX, SSE, SSE2)
+var level2Features = CombineFeatures(CMOV, CMPXCHG8, X87, FXSR, MMX, SSE, SSE2, CX16, LAHF, POPCNT, SSE3, SSE4, SSE42, SSSE3)
+var level3Features = CombineFeatures(CMOV, CMPXCHG8, X87, FXSR, MMX, SSE, SSE2, CX16, LAHF, POPCNT, SSE3, SSE4, SSE42, SSSE3, AVX, AVX2, BMI1, BMI2, F16C, FMA3, LZCNT, MOVBE, OSXSAVE)
+var level4Features = CombineFeatures(CMOV, CMPXCHG8, X87, FXSR, MMX, SSE, SSE2, CX16, LAHF, POPCNT, SSE3, SSE4, SSE42, SSSE3, AVX, AVX2, BMI1, BMI2, F16C, FMA3, LZCNT, MOVBE, OSXSAVE, AVX512F, AVX512BW, AVX512CD, AVX512DQ, AVX512VL)
+
+// X64Level returns the microarchitecture level detected on the CPU.
+// If features are lacking or non x64 mode, 0 is returned.
+// See https://en.wikipedia.org/wiki/X86-64#Microarchitecture_levels
+func (c CPUInfo) X64Level() int {
+        if !c.featureSet.hasOneOf(oneOfLevel) {
+                return 0
+        }
+        if c.featureSet.hasSetP(level4Features) {
+                return 4
+        }
+        if c.featureSet.hasSetP(level3Features) {
+                return 3
+        }
+        if c.featureSet.hasSetP(level2Features) {
+                return 2
+        }
+        if c.featureSet.hasSetP(level1Features) {
+                return 1
+        }
+        return 0
+}
+
+// Disable will disable one or several features.
+func (c *CPUInfo) Disable(ids ...FeatureID) bool {
+        for _, id := range ids {
+                c.featureSet.unset(id)
+        }
+        return true
+}
+
+// Enable will disable one or several features even if they were undetected.
+// This is of course not recommended for obvious reasons.
+func (c *CPUInfo) Enable(ids ...FeatureID) bool {
+        for _, id := range ids {
+                c.featureSet.set(id)
+        }
+        return true
+}
+
+// IsVendor returns true if vendor is recognized as Intel
+func (c CPUInfo) IsVendor(v Vendor) bool {
+        return c.VendorID == v
+}
+
+// FeatureSet returns all available features as strings.
+func (c CPUInfo) FeatureSet() []string {
+        s := make([]string, 0, c.featureSet.nEnabled())
+        s = append(s, c.featureSet.Strings()...)
+        return s
+}
+
+// RTCounter returns the 64-bit time-stamp counter
+// Uses the RDTSCP instruction. The value 0 is returned
+// if the CPU does not support the instruction.
+func (c CPUInfo) RTCounter() uint64 {
+        if !c.Supports(RDTSCP) {
+                return 0
+        }
+        a, _, _, d := rdtscpAsm()
+        return uint64(a) | (uint64(d) << 32)
+}
+
+// Ia32TscAux returns the IA32_TSC_AUX part of the RDTSCP.
+// This variable is OS dependent, but on Linux contains information
+// about the current cpu/core the code is running on.
+// If the RDTSCP instruction isn't supported on the CPU, the value 0 is returned.
+func (c CPUInfo) Ia32TscAux() uint32 {
+        if !c.Supports(RDTSCP) {
+                return 0
+        }
+        _, _, ecx, _ := rdtscpAsm()
+        return ecx
+}
+
+// LogicalCPU will return the Logical CPU the code is currently executing on.
+// This is likely to change when the OS re-schedules the running thread
+// to another CPU.
+// If the current core cannot be detected, -1 will be returned.
+func (c CPUInfo) LogicalCPU() int {
+        if c.maxFunc < 1 {
+                return -1
+        }
+        _, ebx, _, _ := cpuid(1)
+        return int(ebx >> 24)
+}
+
+// frequencies tries to compute the clock speed of the CPU. If leaf 15 is
+// supported, use it, otherwise parse the brand string. Yes, really.
+func (c *CPUInfo) frequencies() {
+        c.Hz, c.BoostFreq = 0, 0
+        mfi := maxFunctionID()
+        if mfi >= 0x15 {
+                eax, ebx, ecx, _ := cpuid(0x15)
+                if eax != 0 && ebx != 0 && ecx != 0 {
+                        c.Hz = (int64(ecx) * int64(ebx)) / int64(eax)
+                }
+        }
+        if mfi >= 0x16 {
+                a, b, _, _ := cpuid(0x16)
+                // Base...
+                if a&0xffff > 0 {
+                        c.Hz = int64(a&0xffff) * 1_000_000
+                }
+                // Boost...
+                if b&0xffff > 0 {
+                        c.BoostFreq = int64(b&0xffff) * 1_000_000
+                }
+        }
+        if c.Hz > 0 {
+                return
+        }
+
+        // computeHz determines the official rated speed of a CPU from its brand
+        // string. This insanity is *actually the official documented way to do
+        // this according to Intel*, prior to leaf 0x15 existing. The official
+        // documentation only shows this working for exactly `x.xx` or `xxxx`
+        // cases, e.g., `2.50GHz` or `1300MHz`; this parser will accept other
+        // sizes.
+        model := c.BrandName
+        hz := strings.LastIndex(model, "Hz")
+        if hz < 3 {
+                return
+        }
+        var multiplier int64
+        switch model[hz-1] {
+        case 'M':
+                multiplier = 1000 * 1000
+        case 'G':
+                multiplier = 1000 * 1000 * 1000
+        case 'T':
+                multiplier = 1000 * 1000 * 1000 * 1000
+        }
+        if multiplier == 0 {
+                return
+        }
+        freq := int64(0)
+        divisor := int64(0)
+        decimalShift := int64(1)
+        var i int
+        for i = hz - 2; i >= 0 && model[i] != ' '; i-- {
+                if model[i] >= '0' && model[i] <= '9' {
+                        freq += int64(model[i]-'0') * decimalShift
+                        decimalShift *= 10
+                } else if model[i] == '.' {
+                        if divisor != 0 {
+                                return
+                        }
+                        divisor = decimalShift
+                } else {
+                        return
+                }
+        }
+        // we didn't find a space
+        if i < 0 {
+                return
+        }
+        if divisor != 0 {
+                c.Hz = (freq * multiplier) / divisor
+                return
+        }
+        c.Hz = freq * multiplier
+}
+
+// VM Will return true if the cpu id indicates we are in
+// a virtual machine.
+func (c CPUInfo) VM() bool {
+        return CPU.featureSet.inSet(HYPERVISOR)
+}
+
+// flags contains detected cpu features and characteristics
+type flags uint64
+
+// log2(bits_in_uint64)
+const flagBitsLog2 = 6
+const flagBits = 1 << flagBitsLog2
+const flagMask = flagBits - 1
+
+// flagSet contains detected cpu features and characteristics in an array of flags
+type flagSet [(lastID + flagMask) / flagBits]flags
+
+func (s *flagSet) inSet(feat FeatureID) bool {
+        return s[feat>>flagBitsLog2]&(1<<(feat&flagMask)) != 0
+}
+
+func (s *flagSet) set(feat FeatureID) {
+        s[feat>>flagBitsLog2] |= 1 << (feat & flagMask)
+}
+
+// setIf will set a feature if boolean is true.
+func (s *flagSet) setIf(cond bool, features ...FeatureID) {
+        if cond {
+                for _, offset := range features {
+                        s[offset>>flagBitsLog2] |= 1 << (offset & flagMask)
+                }
+        }
+}
+
+func (s *flagSet) unset(offset FeatureID) {
+        bit := flags(1 << (offset & flagMask))
+        s[offset>>flagBitsLog2] = s[offset>>flagBitsLog2] & ^bit
+}
+
+// or with another flagset.
+func (s *flagSet) or(other flagSet) {
+        for i, v := range other[:] {
+                s[i] |= v
+        }
+}
+
+// hasSet returns whether all features are present.
+func (s *flagSet) hasSet(other flagSet) bool {
+        for i, v := range other[:] {
+                if s[i]&v != v {
+                        return false
+                }
+        }
+        return true
+}
+
+// hasSet returns whether all features are present.
+func (s *flagSet) hasSetP(other *flagSet) bool {
+        for i, v := range other[:] {
+                if s[i]&v != v {
+                        return false
+                }
+        }
+        return true
+}
+
+// hasOneOf returns whether one or more features are present.
+func (s *flagSet) hasOneOf(other *flagSet) bool {
+        for i, v := range other[:] {
+                if s[i]&v != 0 {
+                        return true
+                }
+        }
+        return false
+}
+
+// nEnabled will return the number of enabled flags.
+func (s *flagSet) nEnabled() (n int) {
+        for _, v := range s[:] {
+                n += bits.OnesCount64(uint64(v))
+        }
+        return n
+}
+
+func flagSetWith(feat ...FeatureID) flagSet {
+        var res flagSet
+        for _, f := range feat {
+                res.set(f)
+        }
+        return res
+}
+
+// ParseFeature will parse the string and return the ID of the matching feature.
+// Will return UNKNOWN if not found.
+func ParseFeature(s string) FeatureID {
+        s = strings.ToUpper(s)
+        for i := firstID; i < lastID; i++ {
+                if i.String() == s {
+                        return i
+                }
+        }
+        return UNKNOWN
+}
+
+// Strings returns an array of the detected features for FlagsSet.
+func (s flagSet) Strings() []string {
+        if len(s) == 0 {
+                return []string{""}
+        }
+        r := make([]string, 0)
+        for i := firstID; i < lastID; i++ {
+                if s.inSet(i) {
+                        r = append(r, i.String())
+                }
+        }
+        return r
+}
+
+func maxExtendedFunction() uint32 {
+        eax, _, _, _ := cpuid(0x80000000)
+        return eax
+}
+
+func maxFunctionID() uint32 {
+        a, _, _, _ := cpuid(0)
+        return a
+}
+
+func brandName() string {
+        if maxExtendedFunction() >= 0x80000004 {
+                v := make([]uint32, 0, 48)
+                for i := uint32(0); i < 3; i++ {
+                        a, b, c, d := cpuid(0x80000002 + i)
+                        v = append(v, a, b, c, d)
+                }
+                return strings.Trim(string(valAsString(v...)), " ")
+        }
+        return "unknown"
+}
+
+func threadsPerCore() int {
+        mfi := maxFunctionID()
+        vend, _ := vendorID()
+
+        if mfi < 0x4 || (vend != Intel && vend != AMD) {
+                return 1
+        }
+
+        if mfi < 0xb {
+                if vend != Intel {
+                        return 1
+                }
+                _, b, _, d := cpuid(1)
+                if (d & (1 << 28)) != 0 {
+                        // v will contain logical core count
+                        v := (b >> 16) & 255
+                        if v > 1 {
+                                a4, _, _, _ := cpuid(4)
+                                // physical cores
+                                v2 := (a4 >> 26) + 1
+                                if v2 > 0 {
+                                        return int(v) / int(v2)
+                                }
+                        }
+                }
+                return 1
+        }
+        _, b, _, _ := cpuidex(0xb, 0)
+        if b&0xffff == 0 {
+                if vend == AMD {
+                        // Workaround for AMD returning 0, assume 2 if >= Zen 2
+                        // It will be more correct than not.
+                        fam, _, _ := familyModel()
+                        _, _, _, d := cpuid(1)
+                        if (d&(1<<28)) != 0 && fam >= 23 {
+                                return 2
+                        }
+                }
+                return 1
+        }
+        return int(b & 0xffff)
+}
+
+func logicalCores() int {
+        mfi := maxFunctionID()
+        v, _ := vendorID()
+        switch v {
+        case Intel:
+                // Use this on old Intel processors
+                if mfi < 0xb {
+                        if mfi < 1 {
+                                return 0
+                        }
+                        // CPUID.1:EBX[23:16] represents the maximum number of addressable IDs (initial APIC ID)
+                        // that can be assigned to logical processors in a physical package.
+                        // The value may not be the same as the number of logical processors that are present in the hardware of a physical package.
+                        _, ebx, _, _ := cpuid(1)
+                        logical := (ebx >> 16) & 0xff
+                        return int(logical)
+                }
+                _, b, _, _ := cpuidex(0xb, 1)
+                return int(b & 0xffff)
+        case AMD, Hygon:
+                _, b, _, _ := cpuid(1)
+                return int((b >> 16) & 0xff)
+        default:
+                return 0
+        }
+}
+
+func familyModel() (family, model, stepping int) {
+        if maxFunctionID() < 0x1 {
+                return 0, 0, 0
+        }
+        eax, _, _, _ := cpuid(1)
+        // If BaseFamily[3:0] is less than Fh then ExtendedFamily[7:0] is reserved and Family is equal to BaseFamily[3:0].
+        family = int((eax >> 8) & 0xf)
+        extFam := family == 0x6 // Intel is 0x6, needs extended model.
+        if family == 0xf {
+                // Add ExtFamily
+                family += int((eax >> 20) & 0xff)
+                extFam = true
+        }
+        // If BaseFamily[3:0] is less than 0Fh then ExtendedModel[3:0] is reserved and Model is equal to BaseModel[3:0].
+        model = int((eax >> 4) & 0xf)
+        if extFam {
+                // Add ExtModel
+                model += int((eax >> 12) & 0xf0)
+        }
+        stepping = int(eax & 0xf)
+        return family, model, stepping
+}
+
+func physicalCores() int {
+        v, _ := vendorID()
+        switch v {
+        case Intel:
+                return logicalCores() / threadsPerCore()
+        case AMD, Hygon:
+                lc := logicalCores()
+                tpc := threadsPerCore()
+                if lc > 0 && tpc > 0 {
+                        return lc / tpc
+                }
+
+                // The following is inaccurate on AMD EPYC 7742 64-Core Processor
+                if maxExtendedFunction() >= 0x80000008 {
+                        _, _, c, _ := cpuid(0x80000008)
+                        if c&0xff > 0 {
+                                return int(c&0xff) + 1
+                        }
+                }
+        }
+        return 0
+}
+
+// Except from http://en.wikipedia.org/wiki/CPUID#EAX.3D0:_Get_vendor_ID
+var vendorMapping = map[string]Vendor{
+        "AMDisbetter!": AMD,
+        "AuthenticAMD": AMD,
+        "CentaurHauls": VIA,
+        "GenuineIntel": Intel,
+        "TransmetaCPU": Transmeta,
+        "GenuineTMx86": Transmeta,
+        "Geode by NSC": NSC,
+        "VIA VIA VIA ": VIA,
+        "KVMKVMKVMKVM": KVM,
+        "Microsoft Hv": MSVM,
+        "VMwareVMware": VMware,
+        "XenVMMXenVMM": XenHVM,
+        "bhyve bhyve ": Bhyve,
+        "HygonGenuine": Hygon,
+        "Vortex86 SoC": SiS,
+        "SiS SiS SiS ": SiS,
+        "RiseRiseRise": SiS,
+        "Genuine  RDC": RDC,
+}
+
+func vendorID() (Vendor, string) {
+        _, b, c, d := cpuid(0)
+        v := string(valAsString(b, d, c))
+        vend, ok := vendorMapping[v]
+        if !ok {
+                return VendorUnknown, v
+        }
+        return vend, v
+}
+
+func cacheLine() int {
+        if maxFunctionID() < 0x1 {
+                return 0
+        }
+
+        _, ebx, _, _ := cpuid(1)
+        cache := (ebx & 0xff00) >> 5 // cflush size
+        if cache == 0 && maxExtendedFunction() >= 0x80000006 {
+                _, _, ecx, _ := cpuid(0x80000006)
+                cache = ecx & 0xff // cacheline size
+        }
+        // TODO: Read from Cache and TLB Information
+        return int(cache)
+}
+
+func (c *CPUInfo) cacheSize() {
+        c.Cache.L1D = -1
+        c.Cache.L1I = -1
+        c.Cache.L2 = -1
+        c.Cache.L3 = -1
+        vendor, _ := vendorID()
+        switch vendor {
+        case Intel:
+                if maxFunctionID() < 4 {
+                        return
+                }
+                c.Cache.L1I, c.Cache.L1D, c.Cache.L2, c.Cache.L3 = 0, 0, 0, 0
+                for i := uint32(0); ; i++ {
+                        eax, ebx, ecx, _ := cpuidex(4, i)
+                        cacheType := eax & 15
+                        if cacheType == 0 {
+                                break
+                        }
+                        cacheLevel := (eax >> 5) & 7
+                        coherency := int(ebx&0xfff) + 1
+                        partitions := int((ebx>>12)&0x3ff) + 1
+                        associativity := int((ebx>>22)&0x3ff) + 1
+                        sets := int(ecx) + 1
+                        size := associativity * partitions * coherency * sets
+                        switch cacheLevel {
+                        case 1:
+                                if cacheType == 1 {
+                                        // 1 = Data Cache
+                                        c.Cache.L1D = size
+                                } else if cacheType == 2 {
+                                        // 2 = Instruction Cache
+                                        c.Cache.L1I = size
+                                } else {
+                                        if c.Cache.L1D < 0 {
+                                                c.Cache.L1I = size
+                                        }
+                                        if c.Cache.L1I < 0 {
+                                                c.Cache.L1I = size
+                                        }
+                                }
+                        case 2:
+                                c.Cache.L2 = size
+                        case 3:
+                                c.Cache.L3 = size
+                        }
+                }
+        case AMD, Hygon:
+                // Untested.
+                if maxExtendedFunction() < 0x80000005 {
+                        return
+                }
+                _, _, ecx, edx := cpuid(0x80000005)
+                c.Cache.L1D = int(((ecx >> 24) & 0xFF) * 1024)
+                c.Cache.L1I = int(((edx >> 24) & 0xFF) * 1024)
+
+                if maxExtendedFunction() < 0x80000006 {
+                        return
+                }
+                _, _, ecx, _ = cpuid(0x80000006)
+                c.Cache.L2 = int(((ecx >> 16) & 0xFFFF) * 1024)
+
+                // CPUID Fn8000_001D_EAX_x[N:0] Cache Properties
+                if maxExtendedFunction() < 0x8000001D || !c.Has(TOPEXT) {
+                        return
+                }
+
+                // Xen Hypervisor is buggy and returns the same entry no matter ECX value.
+                // Hack: When we encounter the same entry 100 times we break.
+                nSame := 0
+                var last uint32
+                for i := uint32(0); i < math.MaxUint32; i++ {
+                        eax, ebx, ecx, _ := cpuidex(0x8000001D, i)
+
+                        level := (eax >> 5) & 7
+                        cacheNumSets := ecx + 1
+                        cacheLineSize := 1 + (ebx & 2047)
+                        cachePhysPartitions := 1 + ((ebx >> 12) & 511)
+                        cacheNumWays := 1 + ((ebx >> 22) & 511)
+
+                        typ := eax & 15
+                        size := int(cacheNumSets * cacheLineSize * cachePhysPartitions * cacheNumWays)
+                        if typ == 0 {
+                                return
+                        }
+
+                        // Check for the same value repeated.
+                        comb := eax ^ ebx ^ ecx
+                        if comb == last {
+                                nSame++
+                                if nSame == 100 {
+                                        return
+                                }
+                        }
+                        last = comb
+
+                        switch level {
+                        case 1:
+                                switch typ {
+                                case 1:
+                                        // Data cache
+                                        c.Cache.L1D = size
+                                case 2:
+                                        // Inst cache
+                                        c.Cache.L1I = size
+                                default:
+                                        if c.Cache.L1D < 0 {
+                                                c.Cache.L1I = size
+                                        }
+                                        if c.Cache.L1I < 0 {
+                                                c.Cache.L1I = size
+                                        }
+                                }
+                        case 2:
+                                c.Cache.L2 = size
+                        case 3:
+                                c.Cache.L3 = size
+                        }
+                }
+        }
+}
+
+type SGXEPCSection struct {
+        BaseAddress uint64
+        EPCSize     uint64
+}
+
+type SGXSupport struct {
+        Available           bool
+        LaunchControl       bool
+        SGX1Supported       bool
+        SGX2Supported       bool
+        MaxEnclaveSizeNot64 int64
+        MaxEnclaveSize64    int64
+        EPCSections         []SGXEPCSection
+}
+
+func hasSGX(available, lc bool) (rval SGXSupport) {
+        rval.Available = available
+
+        if !available {
+                return
+        }
+
+        rval.LaunchControl = lc
+
+        a, _, _, d := cpuidex(0x12, 0)
+        rval.SGX1Supported = a&0x01 != 0
+        rval.SGX2Supported = a&0x02 != 0
+        rval.MaxEnclaveSizeNot64 = 1 << (d & 0xFF)     // pow 2
+        rval.MaxEnclaveSize64 = 1 << ((d >> 8) & 0xFF) // pow 2
+        rval.EPCSections = make([]SGXEPCSection, 0)
+
+        for subleaf := uint32(2); subleaf < 2+8; subleaf++ {
+                eax, ebx, ecx, edx := cpuidex(0x12, subleaf)
+                leafType := eax & 0xf
+
+                if leafType == 0 {
+                        // Invalid subleaf, stop iterating
+                        break
+                } else if leafType == 1 {
+                        // EPC Section subleaf
+                        baseAddress := uint64(eax&0xfffff000) + (uint64(ebx&0x000fffff) << 32)
+                        size := uint64(ecx&0xfffff000) + (uint64(edx&0x000fffff) << 32)
+
+                        section := SGXEPCSection{BaseAddress: baseAddress, EPCSize: size}
+                        rval.EPCSections = append(rval.EPCSections, section)
+                }
+        }
+
+        return
+}
+
+func support() flagSet {
+        var fs flagSet
+        mfi := maxFunctionID()
+        vend, _ := vendorID()
+        if mfi < 0x1 {
+                return fs
+        }
+        family, model, _ := familyModel()
+
+        _, _, c, d := cpuid(1)
+        fs.setIf((d&(1<<0)) != 0, X87)
+        fs.setIf((d&(1<<8)) != 0, CMPXCHG8)
+        fs.setIf((d&(1<<11)) != 0, SYSEE)
+        fs.setIf((d&(1<<15)) != 0, CMOV)
+        fs.setIf((d&(1<<23)) != 0, MMX)
+        fs.setIf((d&(1<<24)) != 0, FXSR)
+        fs.setIf((d&(1<<25)) != 0, FXSROPT)
+        fs.setIf((d&(1<<25)) != 0, SSE)
+        fs.setIf((d&(1<<26)) != 0, SSE2)
+        fs.setIf((c&1) != 0, SSE3)
+        fs.setIf((c&(1<<5)) != 0, VMX)
+        fs.setIf((c&(1<<9)) != 0, SSSE3)
+        fs.setIf((c&(1<<19)) != 0, SSE4)
+        fs.setIf((c&(1<<20)) != 0, SSE42)
+        fs.setIf((c&(1<<25)) != 0, AESNI)
+        fs.setIf((c&(1<<1)) != 0, CLMUL)
+        fs.setIf(c&(1<<22) != 0, MOVBE)
+        fs.setIf(c&(1<<23) != 0, POPCNT)
+        fs.setIf(c&(1<<30) != 0, RDRAND)
+
+        // This bit has been reserved by Intel & AMD for use by hypervisors,
+        // and indicates the presence of a hypervisor.
+        fs.setIf(c&(1<<31) != 0, HYPERVISOR)
+        fs.setIf(c&(1<<29) != 0, F16C)
+        fs.setIf(c&(1<<13) != 0, CX16)
+
+        if vend == Intel && (d&(1<<28)) != 0 && mfi >= 4 {
+                fs.setIf(threadsPerCore() > 1, HTT)
+        }
+        if vend == AMD && (d&(1<<28)) != 0 && mfi >= 4 {
+                fs.setIf(threadsPerCore() > 1, HTT)
+        }
+        fs.setIf(c&1<<26 != 0, XSAVE)
+        fs.setIf(c&1<<27 != 0, OSXSAVE)
+        // Check XGETBV/XSAVE (26), OXSAVE (27) and AVX (28) bits
+        const avxCheck = 1<<26 | 1<<27 | 1<<28
+        if c&avxCheck == avxCheck {
+                // Check for OS support
+                eax, _ := xgetbv(0)
+                if (eax & 0x6) == 0x6 {
+                        fs.set(AVX)
+                        switch vend {
+                        case Intel:
+                                // Older than Haswell.
+                                fs.setIf(family == 6 && model < 60, AVXSLOW)
+                        case AMD:
+                                // Older than Zen 2
+                                fs.setIf(family < 23 || (family == 23 && model < 49), AVXSLOW)
+                        }
+                }
+        }
+        // FMA3 can be used with SSE registers, so no OS support is strictly needed.
+        // fma3 and OSXSAVE needed.
+        const fma3Check = 1<<12 | 1<<27
+        fs.setIf(c&fma3Check == fma3Check, FMA3)
+
+        // Check AVX2, AVX2 requires OS support, but BMI1/2 don't.
+        if mfi >= 7 {
+                _, ebx, ecx, edx := cpuidex(7, 0)
+                if fs.inSet(AVX) && (ebx&0x00000020) != 0 {
+                        fs.set(AVX2)
+                }
+                // CPUID.(EAX=7, ECX=0).EBX
+                if (ebx & 0x00000008) != 0 {
+                        fs.set(BMI1)
+                        fs.setIf((ebx&0x00000100) != 0, BMI2)
+                }
+                fs.setIf(ebx&(1<<2) != 0, SGX)
+                fs.setIf(ebx&(1<<4) != 0, HLE)
+                fs.setIf(ebx&(1<<9) != 0, ERMS)
+                fs.setIf(ebx&(1<<11) != 0, RTM)
+                fs.setIf(ebx&(1<<14) != 0, MPX)
+                fs.setIf(ebx&(1<<18) != 0, RDSEED)
+                fs.setIf(ebx&(1<<19) != 0, ADX)
+                fs.setIf(ebx&(1<<29) != 0, SHA)
+
+                // CPUID.(EAX=7, ECX=0).ECX
+                fs.setIf(ecx&(1<<5) != 0, WAITPKG)
+                fs.setIf(ecx&(1<<7) != 0, CETSS)
+                fs.setIf(ecx&(1<<8) != 0, GFNI)
+                fs.setIf(ecx&(1<<9) != 0, VAES)
+                fs.setIf(ecx&(1<<10) != 0, VPCLMULQDQ)
+                fs.setIf(ecx&(1<<13) != 0, TME)
+                fs.setIf(ecx&(1<<25) != 0, CLDEMOTE)
+                fs.setIf(ecx&(1<<23) != 0, KEYLOCKER)
+                fs.setIf(ecx&(1<<27) != 0, MOVDIRI)
+                fs.setIf(ecx&(1<<28) != 0, MOVDIR64B)
+                fs.setIf(ecx&(1<<29) != 0, ENQCMD)
+                fs.setIf(ecx&(1<<30) != 0, SGXLC)
+
+                // CPUID.(EAX=7, ECX=0).EDX
+                fs.setIf(edx&(1<<4) != 0, FSRM)
+                fs.setIf(edx&(1<<9) != 0, SRBDS_CTRL)
+                fs.setIf(edx&(1<<10) != 0, MD_CLEAR)
+                fs.setIf(edx&(1<<11) != 0, RTM_ALWAYS_ABORT)
+                fs.setIf(edx&(1<<14) != 0, SERIALIZE)
+                fs.setIf(edx&(1<<15) != 0, HYBRID_CPU)
+                fs.setIf(edx&(1<<16) != 0, TSXLDTRK)
+                fs.setIf(edx&(1<<18) != 0, PCONFIG)
+                fs.setIf(edx&(1<<20) != 0, CETIBT)
+                fs.setIf(edx&(1<<26) != 0, IBPB)
+                fs.setIf(edx&(1<<27) != 0, STIBP)
+                fs.setIf(edx&(1<<28) != 0, FLUSH_L1D)
+                fs.setIf(edx&(1<<29) != 0, IA32_ARCH_CAP)
+                fs.setIf(edx&(1<<30) != 0, IA32_CORE_CAP)
+                fs.setIf(edx&(1<<31) != 0, SPEC_CTRL_SSBD)
+
+                // CPUID.(EAX=7, ECX=1).EAX
+                eax1, _, _, edx1 := cpuidex(7, 1)
+                fs.setIf(fs.inSet(AVX) && eax1&(1<<4) != 0, AVXVNNI)
+                fs.setIf(eax1&(1<<7) != 0, CMPCCXADD)
+                fs.setIf(eax1&(1<<10) != 0, MOVSB_ZL)
+                fs.setIf(eax1&(1<<11) != 0, STOSB_SHORT)
+                fs.setIf(eax1&(1<<12) != 0, CMPSB_SCADBS_SHORT)
+                fs.setIf(eax1&(1<<22) != 0, HRESET)
+                fs.setIf(eax1&(1<<23) != 0, AVXIFMA)
+                fs.setIf(eax1&(1<<26) != 0, LAM)
+
+                // CPUID.(EAX=7, ECX=1).EDX
+                fs.setIf(edx1&(1<<4) != 0, AVXVNNIINT8)
+                fs.setIf(edx1&(1<<5) != 0, AVXNECONVERT)
+                fs.setIf(edx1&(1<<14) != 0, PREFETCHI)
+                fs.setIf(edx1&(1<<19) != 0, AVX10)
+                fs.setIf(edx1&(1<<21) != 0, APX_F)
+
+                // Only detect AVX-512 features if XGETBV is supported
+                if c&((1<<26)|(1<<27)) == (1<<26)|(1<<27) {
+                        // Check for OS support
+                        eax, _ := xgetbv(0)
+
+                        // Verify that XCR0[7:5] = ‘111b’ (OPMASK state, upper 256-bit of ZMM0-ZMM15 and
+                        // ZMM16-ZMM31 state are enabled by OS)
+                        /// and that XCR0[2:1] = ‘11b’ (XMM state and YMM state are enabled by OS).
+                        hasAVX512 := (eax>>5)&7 == 7 && (eax>>1)&3 == 3
+                        if runtime.GOOS == "darwin" {
+                                hasAVX512 = fs.inSet(AVX) && darwinHasAVX512()
+                        }
+                        if hasAVX512 {
+                                fs.setIf(ebx&(1<<16) != 0, AVX512F)
+                                fs.setIf(ebx&(1<<17) != 0, AVX512DQ)
+                                fs.setIf(ebx&(1<<21) != 0, AVX512IFMA)
+                                fs.setIf(ebx&(1<<26) != 0, AVX512PF)
+                                fs.setIf(ebx&(1<<27) != 0, AVX512ER)
+                                fs.setIf(ebx&(1<<28) != 0, AVX512CD)
+                                fs.setIf(ebx&(1<<30) != 0, AVX512BW)
+                                fs.setIf(ebx&(1<<31) != 0, AVX512VL)
+                                // ecx
+                                fs.setIf(ecx&(1<<1) != 0, AVX512VBMI)
+                                fs.setIf(ecx&(1<<6) != 0, AVX512VBMI2)
+                                fs.setIf(ecx&(1<<11) != 0, AVX512VNNI)
+                                fs.setIf(ecx&(1<<12) != 0, AVX512BITALG)
+                                fs.setIf(ecx&(1<<14) != 0, AVX512VPOPCNTDQ)
+                                // edx
+                                fs.setIf(edx&(1<<8) != 0, AVX512VP2INTERSECT)
+                                fs.setIf(edx&(1<<22) != 0, AMXBF16)
+                                fs.setIf(edx&(1<<23) != 0, AVX512FP16)
+                                fs.setIf(edx&(1<<24) != 0, AMXTILE)
+                                fs.setIf(edx&(1<<25) != 0, AMXINT8)
+                                // eax1 = CPUID.(EAX=7, ECX=1).EAX
+                                fs.setIf(eax1&(1<<5) != 0, AVX512BF16)
+                                fs.setIf(eax1&(1<<19) != 0, WRMSRNS)
+                                fs.setIf(eax1&(1<<21) != 0, AMXFP16)
+                                fs.setIf(eax1&(1<<27) != 0, MSRLIST)
+                        }
+                }
+
+                // CPUID.(EAX=7, ECX=2)
+                _, _, _, edx = cpuidex(7, 2)
+                fs.setIf(edx&(1<<0) != 0, PSFD)
+                fs.setIf(edx&(1<<1) != 0, IDPRED_CTRL)
+                fs.setIf(edx&(1<<2) != 0, RRSBA_CTRL)
+                fs.setIf(edx&(1<<4) != 0, BHI_CTRL)
+                fs.setIf(edx&(1<<5) != 0, MCDT_NO)
+
+                // Add keylocker features.
+                if fs.inSet(KEYLOCKER) && mfi >= 0x19 {
+                        _, ebx, _, _ := cpuidex(0x19, 0)
+                        fs.setIf(ebx&5 == 5, KEYLOCKERW) // Bit 0 and 2 (1+4)
+                }
+
+                // Add AVX10 features.
+                if fs.inSet(AVX10) && mfi >= 0x24 {
+                        _, ebx, _, _ := cpuidex(0x24, 0)
+                        fs.setIf(ebx&(1<<16) != 0, AVX10_128)
+                        fs.setIf(ebx&(1<<17) != 0, AVX10_256)
+                        fs.setIf(ebx&(1<<18) != 0, AVX10_512)
+                }
+        }
+
+        // Processor Extended State Enumeration Sub-leaf (EAX = 0DH, ECX = 1)
+        // EAX
+        // Bit 00: XSAVEOPT is available.
+        // Bit 01: Supports XSAVEC and the compacted form of XRSTOR if set.
+        // Bit 02: Supports XGETBV with ECX = 1 if set.
+        // Bit 03: Supports XSAVES/XRSTORS and IA32_XSS if set.
+        // Bits 31 - 04: Reserved.
+        // EBX
+        // Bits 31 - 00: The size in bytes of the XSAVE area containing all states enabled by XCRO | IA32_XSS.
+        // ECX
+        // Bits 31 - 00: Reports the supported bits of the lower 32 bits of the IA32_XSS MSR. IA32_XSS[n] can be set to 1 only if ECX[n] is 1.
+        // EDX?
+        // Bits 07 - 00: Used for XCR0. Bit 08: PT state. Bit 09: Used for XCR0. Bits 12 - 10: Reserved. Bit 13: HWP state. Bits 31 - 14: Reserved.
+        if mfi >= 0xd {
+                if fs.inSet(XSAVE) {
+                        eax, _, _, _ := cpuidex(0xd, 1)
+                        fs.setIf(eax&(1<<0) != 0, XSAVEOPT)
+                        fs.setIf(eax&(1<<1) != 0, XSAVEC)
+                        fs.setIf(eax&(1<<2) != 0, XGETBV1)
+                        fs.setIf(eax&(1<<3) != 0, XSAVES)
+                }
+        }
+        if maxExtendedFunction() >= 0x80000001 {
+                _, _, c, d := cpuid(0x80000001)
+                if (c & (1 << 5)) != 0 {
+                        fs.set(LZCNT)
+                        fs.set(POPCNT)
+                }
+                // ECX
+                fs.setIf((c&(1<<0)) != 0, LAHF)
+                fs.setIf((c&(1<<2)) != 0, SVM)
+                fs.setIf((c&(1<<6)) != 0, SSE4A)
+                fs.setIf((c&(1<<10)) != 0, IBS)
+                fs.setIf((c&(1<<22)) != 0, TOPEXT)
+
+                // EDX
+                fs.setIf(d&(1<<11) != 0, SYSCALL)
+                fs.setIf(d&(1<<20) != 0, NX)
+                fs.setIf(d&(1<<22) != 0, MMXEXT)
+                fs.setIf(d&(1<<23) != 0, MMX)
+                fs.setIf(d&(1<<24) != 0, FXSR)
+                fs.setIf(d&(1<<25) != 0, FXSROPT)
+                fs.setIf(d&(1<<27) != 0, RDTSCP)
+                fs.setIf(d&(1<<30) != 0, AMD3DNOWEXT)
+                fs.setIf(d&(1<<31) != 0, AMD3DNOW)
+
+                /* XOP and FMA4 use the AVX instruction coding scheme, so they can't be
+                 * used unless the OS has AVX support. */
+                if fs.inSet(AVX) {
+                        fs.setIf((c&(1<<11)) != 0, XOP)
+                        fs.setIf((c&(1<<16)) != 0, FMA4)
+                }
+
+        }
+        if maxExtendedFunction() >= 0x80000007 {
+                _, b, _, d := cpuid(0x80000007)
+                fs.setIf((b&(1<<0)) != 0, MCAOVERFLOW)
+                fs.setIf((b&(1<<1)) != 0, SUCCOR)
+                fs.setIf((b&(1<<2)) != 0, HWA)
+                fs.setIf((d&(1<<9)) != 0, CPBOOST)
+        }
+
+        if maxExtendedFunction() >= 0x80000008 {
+                _, b, _, _ := cpuid(0x80000008)
+                fs.setIf(b&(1<<28) != 0, PSFD)
+                fs.setIf(b&(1<<27) != 0, CPPC)
+                fs.setIf(b&(1<<24) != 0, SPEC_CTRL_SSBD)
+                fs.setIf(b&(1<<23) != 0, PPIN)
+                fs.setIf(b&(1<<21) != 0, TLB_FLUSH_NESTED)
+                fs.setIf(b&(1<<20) != 0, EFER_LMSLE_UNS)
+                fs.setIf(b&(1<<19) != 0, IBRS_PROVIDES_SMP)
+                fs.setIf(b&(1<<18) != 0, IBRS_PREFERRED)
+                fs.setIf(b&(1<<17) != 0, STIBP_ALWAYSON)
+                fs.setIf(b&(1<<15) != 0, STIBP)
+                fs.setIf(b&(1<<14) != 0, IBRS)
+                fs.setIf((b&(1<<13)) != 0, INT_WBINVD)
+                fs.setIf(b&(1<<12) != 0, IBPB)
+                fs.setIf((b&(1<<9)) != 0, WBNOINVD)
+                fs.setIf((b&(1<<8)) != 0, MCOMMIT)
+                fs.setIf((b&(1<<4)) != 0, RDPRU)
+                fs.setIf((b&(1<<3)) != 0, INVLPGB)
+                fs.setIf((b&(1<<1)) != 0, MSRIRC)
+                fs.setIf((b&(1<<0)) != 0, CLZERO)
+        }
+
+        if fs.inSet(SVM) && maxExtendedFunction() >= 0x8000000A {
+                _, _, _, edx := cpuid(0x8000000A)
+                fs.setIf((edx>>0)&1 == 1, SVMNP)
+                fs.setIf((edx>>1)&1 == 1, LBRVIRT)
+                fs.setIf((edx>>2)&1 == 1, SVML)
+                fs.setIf((edx>>3)&1 == 1, NRIPS)
+                fs.setIf((edx>>4)&1 == 1, TSCRATEMSR)
+                fs.setIf((edx>>5)&1 == 1, VMCBCLEAN)
+                fs.setIf((edx>>6)&1 == 1, SVMFBASID)
+                fs.setIf((edx>>7)&1 == 1, SVMDA)
+                fs.setIf((edx>>10)&1 == 1, SVMPF)
+                fs.setIf((edx>>12)&1 == 1, SVMPFT)
+        }
+
+        if maxExtendedFunction() >= 0x8000001a {
+                eax, _, _, _ := cpuid(0x8000001a)
+                fs.setIf((eax>>0)&1 == 1, FP128)
+                fs.setIf((eax>>1)&1 == 1, MOVU)
+                fs.setIf((eax>>2)&1 == 1, FP256)
+        }
+
+        if maxExtendedFunction() >= 0x8000001b && fs.inSet(IBS) {
+                eax, _, _, _ := cpuid(0x8000001b)
+                fs.setIf((eax>>0)&1 == 1, IBSFFV)
+                fs.setIf((eax>>1)&1 == 1, IBSFETCHSAM)
+                fs.setIf((eax>>2)&1 == 1, IBSOPSAM)
+                fs.setIf((eax>>3)&1 == 1, IBSRDWROPCNT)
+                fs.setIf((eax>>4)&1 == 1, IBSOPCNT)
+                fs.setIf((eax>>5)&1 == 1, IBSBRNTRGT)
+                fs.setIf((eax>>6)&1 == 1, IBSOPCNTEXT)
+                fs.setIf((eax>>7)&1 == 1, IBSRIPINVALIDCHK)
+                fs.setIf((eax>>8)&1 == 1, IBS_OPFUSE)
+                fs.setIf((eax>>9)&1 == 1, IBS_FETCH_CTLX)
+                fs.setIf((eax>>10)&1 == 1, IBS_OPDATA4) // Doc says "Fixed,0. IBS op data 4 MSR supported", but assuming they mean 1.
+                fs.setIf((eax>>11)&1 == 1, IBS_ZEN4)
+        }
+
+        if maxExtendedFunction() >= 0x8000001f && vend == AMD {
+                a, _, _, _ := cpuid(0x8000001f)
+                fs.setIf((a>>0)&1 == 1, SME)
+                fs.setIf((a>>1)&1 == 1, SEV)
+                fs.setIf((a>>2)&1 == 1, MSR_PAGEFLUSH)
+                fs.setIf((a>>3)&1 == 1, SEV_ES)
+                fs.setIf((a>>4)&1 == 1, SEV_SNP)
+                fs.setIf((a>>5)&1 == 1, VMPL)
+                fs.setIf((a>>10)&1 == 1, SME_COHERENT)
+                fs.setIf((a>>11)&1 == 1, SEV_64BIT)
+                fs.setIf((a>>12)&1 == 1, SEV_RESTRICTED)
+                fs.setIf((a>>13)&1 == 1, SEV_ALTERNATIVE)
+                fs.setIf((a>>14)&1 == 1, SEV_DEBUGSWAP)
+                fs.setIf((a>>15)&1 == 1, IBS_PREVENTHOST)
+                fs.setIf((a>>16)&1 == 1, VTE)
+                fs.setIf((a>>24)&1 == 1, VMSA_REGPROT)
+        }
+
+        if mfi >= 0x20 {
+                // Microsoft has decided to purposefully hide the information
+                // of the guest TEE when VMs are being created using Hyper-V.
+                //
+                // This leads us to check for the Hyper-V cpuid features
+                // (0x4000000C), and then for the `ebx` value set.
+                //
+                // For Intel TDX, `ebx` is set as `0xbe3`, being 3 the part
+                // we're mostly interested about,according to:
+                // https://github.com/torvalds/linux/blob/d2f51b3516dade79269ff45eae2a7668ae711b25/arch/x86/include/asm/hyperv-tlfs.h#L169-L174
+                _, ebx, _, _ := cpuid(0x4000000C)
+                fs.setIf(ebx == 0xbe3, TDX_GUEST)
+        }
+
+        if mfi >= 0x21 {
+                // Intel Trusted Domain Extensions Guests have their own cpuid leaf (0x21).
+                _, ebx, ecx, edx := cpuid(0x21)
+                identity := string(valAsString(ebx, edx, ecx))
+                fs.setIf(identity == "IntelTDX    ", TDX_GUEST)
+        }
+
+        return fs
+}
+
+func (c *CPUInfo) supportAVX10() uint8 {
+        if c.maxFunc >= 0x24 && c.featureSet.inSet(AVX10) {
+                _, ebx, _, _ := cpuidex(0x24, 0)
+                return uint8(ebx)
+        }
+        return 0
+}
+
+func valAsString(values ...uint32) []byte {
+        r := make([]byte, 4*len(values))
+        for i, v := range values {
+                dst := r[i*4:]
+                dst[0] = byte(v & 0xff)
+                dst[1] = byte((v >> 8) & 0xff)
+                dst[2] = byte((v >> 16) & 0xff)
+                dst[3] = byte((v >> 24) & 0xff)
+                switch {
+                case dst[0] == 0:
+                        return r[:i*4]
+                case dst[1] == 0:
+                        return r[:i*4+1]
+                case dst[2] == 0:
+                        return r[:i*4+2]
+                case dst[3] == 0:
+                        return r[:i*4+3]
+                }
+        }
+        return r
+}
diff --git a/vendor/github.com/klauspost/cpuid/v2/cpuid_386.s b/vendor/github.com/klauspost/cpuid/v2/cpuid_386.s
new file mode 100644
index 0000000..8587c3a
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/cpuid_386.s
@@ -0,0 +1,47 @@
+// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
+
+//+build 386,!gccgo,!noasm,!appengine
+
+// func asmCpuid(op uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·asmCpuid(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 asmCpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·asmCpuidex(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 ·asmXgetbv(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
+
+// func asmRdtscpAsm() (eax, ebx, ecx, edx uint32)
+TEXT ·asmRdtscpAsm(SB), 7, $0
+        BYTE $0x0F; BYTE $0x01; BYTE $0xF9 // RDTSCP
+        MOVL AX, eax+0(FP)
+        MOVL BX, ebx+4(FP)
+        MOVL CX, ecx+8(FP)
+        MOVL DX, edx+12(FP)
+        RET
+
+// func asmDarwinHasAVX512() bool
+TEXT ·asmDarwinHasAVX512(SB), 7, $0
+        MOVL $0, eax+0(FP)
+        RET
diff --git a/vendor/github.com/klauspost/cpuid/v2/cpuid_amd64.s b/vendor/github.com/klauspost/cpuid/v2/cpuid_amd64.s
new file mode 100644
index 0000000..bc11f89
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/cpuid_amd64.s
@@ -0,0 +1,72 @@
+// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
+
+//+build amd64,!gccgo,!noasm,!appengine
+
+// func asmCpuid(op uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·asmCpuid(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 asmCpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+TEXT ·asmCpuidex(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 asmXgetbv(index uint32) (eax, edx uint32)
+TEXT ·asmXgetbv(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
+
+// func asmRdtscpAsm() (eax, ebx, ecx, edx uint32)
+TEXT ·asmRdtscpAsm(SB), 7, $0
+        BYTE $0x0F; BYTE $0x01; BYTE $0xF9 // RDTSCP
+        MOVL AX, eax+0(FP)
+        MOVL BX, ebx+4(FP)
+        MOVL CX, ecx+8(FP)
+        MOVL DX, edx+12(FP)
+        RET
+
+// From https://go-review.googlesource.com/c/sys/+/285572/
+// func asmDarwinHasAVX512() bool
+TEXT ·asmDarwinHasAVX512(SB), 7, $0-1
+        MOVB $0, ret+0(FP) // default to false
+
+#ifdef GOOS_darwin // return if not darwin
+#ifdef GOARCH_amd64 // return if not amd64
+// These values from:
+// https://github.com/apple/darwin-xnu/blob/xnu-4570.1.46/osfmk/i386/cpu_capabilities.h
+#define commpage64_base_address         0x00007fffffe00000
+#define commpage64_cpu_capabilities64   (commpage64_base_address+0x010)
+#define commpage64_version              (commpage64_base_address+0x01E)
+#define hasAVX512F                      0x0000004000000000
+        MOVQ $commpage64_version, BX
+        MOVW (BX), AX
+        CMPW AX, $13                            // versions < 13 do not support AVX512
+        JL   no_avx512
+        MOVQ $commpage64_cpu_capabilities64, BX
+        MOVQ (BX), AX
+        MOVQ $hasAVX512F, CX
+        ANDQ CX, AX
+        JZ   no_avx512
+        MOVB $1, ret+0(FP)
+
+no_avx512:
+#endif
+#endif
+        RET
+
diff --git a/vendor/github.com/klauspost/cpuid/v2/cpuid_arm64.s b/vendor/github.com/klauspost/cpuid/v2/cpuid_arm64.s
new file mode 100644
index 0000000..b31d6ae
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/cpuid_arm64.s
@@ -0,0 +1,26 @@
+// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
+
+//+build arm64,!gccgo,!noasm,!appengine
+
+// See https://www.kernel.org/doc/Documentation/arm64/cpu-feature-registers.txt
+
+// func getMidr
+TEXT ·getMidr(SB), 7, $0
+        WORD $0xd5380000    // mrs x0, midr_el1         /* Main ID Register */
+        MOVD R0, midr+0(FP)
+        RET
+
+// func getProcFeatures
+TEXT ·getProcFeatures(SB), 7, $0
+        WORD $0xd5380400            // mrs x0, id_aa64pfr0_el1  /* Processor Feature Register 0 */
+        MOVD R0, procFeatures+0(FP)
+        RET
+
+// func getInstAttributes
+TEXT ·getInstAttributes(SB), 7, $0
+        WORD $0xd5380600            // mrs x0, id_aa64isar0_el1 /* Instruction Set Attribute Register 0 */
+        WORD $0xd5380621            // mrs x1, id_aa64isar1_el1 /* Instruction Set Attribute Register 1 */
+        MOVD R0, instAttrReg0+0(FP)
+        MOVD R1, instAttrReg1+8(FP)
+        RET
+
diff --git a/vendor/github.com/klauspost/cpuid/v2/detect_arm64.go b/vendor/github.com/klauspost/cpuid/v2/detect_arm64.go
new file mode 100644
index 0000000..9a53504
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/detect_arm64.go
@@ -0,0 +1,247 @@
+// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
+
+//go:build arm64 && !gccgo && !noasm && !appengine
+// +build arm64,!gccgo,!noasm,!appengine
+
+package cpuid
+
+import "runtime"
+
+func getMidr() (midr uint64)
+func getProcFeatures() (procFeatures uint64)
+func getInstAttributes() (instAttrReg0, instAttrReg1 uint64)
+
+func initCPU() {
+        cpuid = func(uint32) (a, b, c, d uint32) { return 0, 0, 0, 0 }
+        cpuidex = func(x, y uint32) (a, b, c, d uint32) { return 0, 0, 0, 0 }
+        xgetbv = func(uint32) (a, b uint32) { return 0, 0 }
+        rdtscpAsm = func() (a, b, c, d uint32) { return 0, 0, 0, 0 }
+}
+
+func addInfo(c *CPUInfo, safe bool) {
+        // Seems to be safe to assume on ARM64
+        c.CacheLine = 64
+        detectOS(c)
+
+        // ARM64 disabled since it may crash if interrupt is not intercepted by OS.
+        if safe && !c.Supports(ARMCPUID) && runtime.GOOS != "freebsd" {
+                return
+        }
+        midr := getMidr()
+
+        // MIDR_EL1 - Main ID Register
+        // https://developer.arm.com/docs/ddi0595/h/aarch64-system-registers/midr_el1
+        //  x--------------------------------------------------x
+        //  | Name                         |  bits   | visible |
+        //  |--------------------------------------------------|
+        //  | Implementer                  | [31-24] |    y    |
+        //  |--------------------------------------------------|
+        //  | Variant                      | [23-20] |    y    |
+        //  |--------------------------------------------------|
+        //  | Architecture                 | [19-16] |    y    |
+        //  |--------------------------------------------------|
+        //  | PartNum                      | [15-4]  |    y    |
+        //  |--------------------------------------------------|
+        //  | Revision                     | [3-0]   |    y    |
+        //  x--------------------------------------------------x
+
+        switch (midr >> 24) & 0xff {
+        case 0xC0:
+                c.VendorString = "Ampere Computing"
+                c.VendorID = Ampere
+        case 0x41:
+                c.VendorString = "Arm Limited"
+                c.VendorID = ARM
+        case 0x42:
+                c.VendorString = "Broadcom Corporation"
+                c.VendorID = Broadcom
+        case 0x43:
+                c.VendorString = "Cavium Inc"
+                c.VendorID = Cavium
+        case 0x44:
+                c.VendorString = "Digital Equipment Corporation"
+                c.VendorID = DEC
+        case 0x46:
+                c.VendorString = "Fujitsu Ltd"
+                c.VendorID = Fujitsu
+        case 0x49:
+                c.VendorString = "Infineon Technologies AG"
+                c.VendorID = Infineon
+        case 0x4D:
+                c.VendorString = "Motorola or Freescale Semiconductor Inc"
+                c.VendorID = Motorola
+        case 0x4E:
+                c.VendorString = "NVIDIA Corporation"
+                c.VendorID = NVIDIA
+        case 0x50:
+                c.VendorString = "Applied Micro Circuits Corporation"
+                c.VendorID = AMCC
+        case 0x51:
+                c.VendorString = "Qualcomm Inc"
+                c.VendorID = Qualcomm
+        case 0x56:
+                c.VendorString = "Marvell International Ltd"
+                c.VendorID = Marvell
+        case 0x69:
+                c.VendorString = "Intel Corporation"
+                c.VendorID = Intel
+        }
+
+        // Lower 4 bits: Architecture
+        // Architecture Meaning
+        // 0b0001               Armv4.
+        // 0b0010               Armv4T.
+        // 0b0011               Armv5 (obsolete).
+        // 0b0100               Armv5T.
+        // 0b0101               Armv5TE.
+        // 0b0110               Armv5TEJ.
+        // 0b0111               Armv6.
+        // 0b1111               Architectural features are individually identified in the ID_* registers, see 'ID registers'.
+        // Upper 4 bit: Variant
+        // An IMPLEMENTATION DEFINED variant number.
+        // Typically, this field is used to distinguish between different product variants, or major revisions of a product.
+        c.Family = int(midr>>16) & 0xff
+
+        // PartNum, bits [15:4]
+        // An IMPLEMENTATION DEFINED primary part number for the device.
+        // On processors implemented by Arm, if the top four bits of the primary
+        // part number are 0x0 or 0x7, the variant and architecture are encoded differently.
+        // Revision, bits [3:0]
+        // An IMPLEMENTATION DEFINED revision number for the device.
+        c.Model = int(midr) & 0xffff
+
+        procFeatures := getProcFeatures()
+
+        // ID_AA64PFR0_EL1 - Processor Feature Register 0
+        // x--------------------------------------------------x
+        // | Name                         |  bits   | visible |
+        // |--------------------------------------------------|
+        // | DIT                          | [51-48] |    y    |
+        // |--------------------------------------------------|
+        // | SVE                          | [35-32] |    y    |
+        // |--------------------------------------------------|
+        // | GIC                          | [27-24] |    n    |
+        // |--------------------------------------------------|
+        // | AdvSIMD                      | [23-20] |    y    |
+        // |--------------------------------------------------|
+        // | FP                           | [19-16] |    y    |
+        // |--------------------------------------------------|
+        // | EL3                          | [15-12] |    n    |
+        // |--------------------------------------------------|
+        // | EL2                          | [11-8]  |    n    |
+        // |--------------------------------------------------|
+        // | EL1                          | [7-4]   |    n    |
+        // |--------------------------------------------------|
+        // | EL0                          | [3-0]   |    n    |
+        // x--------------------------------------------------x
+
+        var f flagSet
+        // if procFeatures&(0xf<<48) != 0 {
+        //      fmt.Println("DIT")
+        // }
+        f.setIf(procFeatures&(0xf<<32) != 0, SVE)
+        if procFeatures&(0xf<<20) != 15<<20 {
+                f.set(ASIMD)
+                // https://developer.arm.com/docs/ddi0595/b/aarch64-system-registers/id_aa64pfr0_el1
+                // 0b0001 --> As for 0b0000, and also includes support for half-precision floating-point arithmetic.
+                f.setIf(procFeatures&(0xf<<20) == 1<<20, FPHP, ASIMDHP)
+        }
+        f.setIf(procFeatures&(0xf<<16) != 0, FP)
+
+        instAttrReg0, instAttrReg1 := getInstAttributes()
+
+        // https://developer.arm.com/docs/ddi0595/b/aarch64-system-registers/id_aa64isar0_el1
+        //
+        // ID_AA64ISAR0_EL1 - Instruction Set Attribute Register 0
+        // x--------------------------------------------------x
+        // | Name                         |  bits   | visible |
+        // |--------------------------------------------------|
+        // | TS                           | [55-52] |    y    |
+        // |--------------------------------------------------|
+        // | FHM                          | [51-48] |    y    |
+        // |--------------------------------------------------|
+        // | DP                           | [47-44] |    y    |
+        // |--------------------------------------------------|
+        // | SM4                          | [43-40] |    y    |
+        // |--------------------------------------------------|
+        // | SM3                          | [39-36] |    y    |
+        // |--------------------------------------------------|
+        // | SHA3                         | [35-32] |    y    |
+        // |--------------------------------------------------|
+        // | RDM                          | [31-28] |    y    |
+        // |--------------------------------------------------|
+        // | ATOMICS                      | [23-20] |    y    |
+        // |--------------------------------------------------|
+        // | CRC32                        | [19-16] |    y    |
+        // |--------------------------------------------------|
+        // | SHA2                         | [15-12] |    y    |
+        // |--------------------------------------------------|
+        // | SHA1                         | [11-8]  |    y    |
+        // |--------------------------------------------------|
+        // | AES                          | [7-4]   |    y    |
+        // x--------------------------------------------------x
+
+        // if instAttrReg0&(0xf<<52) != 0 {
+        //      fmt.Println("TS")
+        // }
+        // if instAttrReg0&(0xf<<48) != 0 {
+        //      fmt.Println("FHM")
+        // }
+        f.setIf(instAttrReg0&(0xf<<44) != 0, ASIMDDP)
+        f.setIf(instAttrReg0&(0xf<<40) != 0, SM4)
+        f.setIf(instAttrReg0&(0xf<<36) != 0, SM3)
+        f.setIf(instAttrReg0&(0xf<<32) != 0, SHA3)
+        f.setIf(instAttrReg0&(0xf<<28) != 0, ASIMDRDM)
+        f.setIf(instAttrReg0&(0xf<<20) != 0, ATOMICS)
+        f.setIf(instAttrReg0&(0xf<<16) != 0, CRC32)
+        f.setIf(instAttrReg0&(0xf<<12) != 0, SHA2)
+        // https://developer.arm.com/docs/ddi0595/b/aarch64-system-registers/id_aa64isar0_el1
+        // 0b0010 --> As 0b0001, plus SHA512H, SHA512H2, SHA512SU0, and SHA512SU1 instructions implemented.
+        f.setIf(instAttrReg0&(0xf<<12) == 2<<12, SHA512)
+        f.setIf(instAttrReg0&(0xf<<8) != 0, SHA1)
+        f.setIf(instAttrReg0&(0xf<<4) != 0, AESARM)
+        // https://developer.arm.com/docs/ddi0595/b/aarch64-system-registers/id_aa64isar0_el1
+        // 0b0010 --> As for 0b0001, plus PMULL/PMULL2 instructions operating on 64-bit data quantities.
+        f.setIf(instAttrReg0&(0xf<<4) == 2<<4, PMULL)
+
+        // https://developer.arm.com/docs/ddi0595/b/aarch64-system-registers/id_aa64isar1_el1
+        //
+        // ID_AA64ISAR1_EL1 - Instruction set attribute register 1
+        // x--------------------------------------------------x
+        // | Name                         |  bits   | visible |
+        // |--------------------------------------------------|
+        // | GPI                          | [31-28] |    y    |
+        // |--------------------------------------------------|
+        // | GPA                          | [27-24] |    y    |
+        // |--------------------------------------------------|
+        // | LRCPC                        | [23-20] |    y    |
+        // |--------------------------------------------------|
+        // | FCMA                         | [19-16] |    y    |
+        // |--------------------------------------------------|
+        // | JSCVT                        | [15-12] |    y    |
+        // |--------------------------------------------------|
+        // | API                          | [11-8]  |    y    |
+        // |--------------------------------------------------|
+        // | APA                          | [7-4]   |    y    |
+        // |--------------------------------------------------|
+        // | DPB                          | [3-0]   |    y    |
+        // x--------------------------------------------------x
+
+        // if instAttrReg1&(0xf<<28) != 0 {
+        //      fmt.Println("GPI")
+        // }
+        f.setIf(instAttrReg1&(0xf<<28) != 24, GPA)
+        f.setIf(instAttrReg1&(0xf<<20) != 0, LRCPC)
+        f.setIf(instAttrReg1&(0xf<<16) != 0, FCMA)
+        f.setIf(instAttrReg1&(0xf<<12) != 0, JSCVT)
+        // if instAttrReg1&(0xf<<8) != 0 {
+        //      fmt.Println("API")
+        // }
+        // if instAttrReg1&(0xf<<4) != 0 {
+        //      fmt.Println("APA")
+        // }
+        f.setIf(instAttrReg1&(0xf<<0) != 0, DCPOP)
+
+        // Store
+        c.featureSet.or(f)
+}
diff --git a/vendor/github.com/klauspost/cpuid/v2/detect_ref.go b/vendor/github.com/klauspost/cpuid/v2/detect_ref.go
new file mode 100644
index 0000000..9636c2b
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/detect_ref.go
@@ -0,0 +1,15 @@
+// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
+
+//go:build (!amd64 && !386 && !arm64) || gccgo || noasm || appengine
+// +build !amd64,!386,!arm64 gccgo noasm appengine
+
+package cpuid
+
+func initCPU() {
+        cpuid = func(uint32) (a, b, c, d uint32) { return 0, 0, 0, 0 }
+        cpuidex = func(x, y uint32) (a, b, c, d uint32) { return 0, 0, 0, 0 }
+        xgetbv = func(uint32) (a, b uint32) { return 0, 0 }
+        rdtscpAsm = func() (a, b, c, d uint32) { return 0, 0, 0, 0 }
+}
+
+func addInfo(info *CPUInfo, safe bool) {}
diff --git a/vendor/github.com/klauspost/cpuid/v2/detect_x86.go b/vendor/github.com/klauspost/cpuid/v2/detect_x86.go
new file mode 100644
index 0000000..c7dfa12
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/detect_x86.go
@@ -0,0 +1,37 @@
+// Copyright (c) 2015 Klaus Post, released under MIT License. See LICENSE file.
+
+//go:build (386 && !gccgo && !noasm && !appengine) || (amd64 && !gccgo && !noasm && !appengine)
+// +build 386,!gccgo,!noasm,!appengine amd64,!gccgo,!noasm,!appengine
+
+package cpuid
+
+func asmCpuid(op uint32) (eax, ebx, ecx, edx uint32)
+func asmCpuidex(op, op2 uint32) (eax, ebx, ecx, edx uint32)
+func asmXgetbv(index uint32) (eax, edx uint32)
+func asmRdtscpAsm() (eax, ebx, ecx, edx uint32)
+func asmDarwinHasAVX512() bool
+
+func initCPU() {
+        cpuid = asmCpuid
+        cpuidex = asmCpuidex
+        xgetbv = asmXgetbv
+        rdtscpAsm = asmRdtscpAsm
+        darwinHasAVX512 = asmDarwinHasAVX512
+}
+
+func addInfo(c *CPUInfo, safe bool) {
+        c.maxFunc = maxFunctionID()
+        c.maxExFunc = maxExtendedFunction()
+        c.BrandName = brandName()
+        c.CacheLine = cacheLine()
+        c.Family, c.Model, c.Stepping = familyModel()
+        c.featureSet = support()
+        c.SGX = hasSGX(c.featureSet.inSet(SGX), c.featureSet.inSet(SGXLC))
+        c.ThreadsPerCore = threadsPerCore()
+        c.LogicalCores = logicalCores()
+        c.PhysicalCores = physicalCores()
+        c.VendorID, c.VendorString = vendorID()
+        c.AVX10Level = c.supportAVX10()
+        c.cacheSize()
+        c.frequencies()
+}
diff --git a/vendor/github.com/klauspost/cpuid/v2/featureid_string.go b/vendor/github.com/klauspost/cpuid/v2/featureid_string.go
new file mode 100644
index 0000000..43bd05f
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/featureid_string.go
@@ -0,0 +1,279 @@
+// Code generated by "stringer -type=FeatureID,Vendor"; DO NOT EDIT.
+
+package cpuid
+
+import "strconv"
+
+func _() {
+        // An "invalid array index" compiler error signifies that the constant values have changed.
+        // Re-run the stringer command to generate them again.
+        var x [1]struct{}
+        _ = x[ADX-1]
+        _ = x[AESNI-2]
+        _ = x[AMD3DNOW-3]
+        _ = x[AMD3DNOWEXT-4]
+        _ = x[AMXBF16-5]
+        _ = x[AMXFP16-6]
+        _ = x[AMXINT8-7]
+        _ = x[AMXTILE-8]
+        _ = x[APX_F-9]
+        _ = x[AVX-10]
+        _ = x[AVX10-11]
+        _ = x[AVX10_128-12]
+        _ = x[AVX10_256-13]
+        _ = x[AVX10_512-14]
+        _ = x[AVX2-15]
+        _ = x[AVX512BF16-16]
+        _ = x[AVX512BITALG-17]
+        _ = x[AVX512BW-18]
+        _ = x[AVX512CD-19]
+        _ = x[AVX512DQ-20]
+        _ = x[AVX512ER-21]
+        _ = x[AVX512F-22]
+        _ = x[AVX512FP16-23]
+        _ = x[AVX512IFMA-24]
+        _ = x[AVX512PF-25]
+        _ = x[AVX512VBMI-26]
+        _ = x[AVX512VBMI2-27]
+        _ = x[AVX512VL-28]
+        _ = x[AVX512VNNI-29]
+        _ = x[AVX512VP2INTERSECT-30]
+        _ = x[AVX512VPOPCNTDQ-31]
+        _ = x[AVXIFMA-32]
+        _ = x[AVXNECONVERT-33]
+        _ = x[AVXSLOW-34]
+        _ = x[AVXVNNI-35]
+        _ = x[AVXVNNIINT8-36]
+        _ = x[BHI_CTRL-37]
+        _ = x[BMI1-38]
+        _ = x[BMI2-39]
+        _ = x[CETIBT-40]
+        _ = x[CETSS-41]
+        _ = x[CLDEMOTE-42]
+        _ = x[CLMUL-43]
+        _ = x[CLZERO-44]
+        _ = x[CMOV-45]
+        _ = x[CMPCCXADD-46]
+        _ = x[CMPSB_SCADBS_SHORT-47]
+        _ = x[CMPXCHG8-48]
+        _ = x[CPBOOST-49]
+        _ = x[CPPC-50]
+        _ = x[CX16-51]
+        _ = x[EFER_LMSLE_UNS-52]
+        _ = x[ENQCMD-53]
+        _ = x[ERMS-54]
+        _ = x[F16C-55]
+        _ = x[FLUSH_L1D-56]
+        _ = x[FMA3-57]
+        _ = x[FMA4-58]
+        _ = x[FP128-59]
+        _ = x[FP256-60]
+        _ = x[FSRM-61]
+        _ = x[FXSR-62]
+        _ = x[FXSROPT-63]
+        _ = x[GFNI-64]
+        _ = x[HLE-65]
+        _ = x[HRESET-66]
+        _ = x[HTT-67]
+        _ = x[HWA-68]
+        _ = x[HYBRID_CPU-69]
+        _ = x[HYPERVISOR-70]
+        _ = x[IA32_ARCH_CAP-71]
+        _ = x[IA32_CORE_CAP-72]
+        _ = x[IBPB-73]
+        _ = x[IBRS-74]
+        _ = x[IBRS_PREFERRED-75]
+        _ = x[IBRS_PROVIDES_SMP-76]
+        _ = x[IBS-77]
+        _ = x[IBSBRNTRGT-78]
+        _ = x[IBSFETCHSAM-79]
+        _ = x[IBSFFV-80]
+        _ = x[IBSOPCNT-81]
+        _ = x[IBSOPCNTEXT-82]
+        _ = x[IBSOPSAM-83]
+        _ = x[IBSRDWROPCNT-84]
+        _ = x[IBSRIPINVALIDCHK-85]
+        _ = x[IBS_FETCH_CTLX-86]
+        _ = x[IBS_OPDATA4-87]
+        _ = x[IBS_OPFUSE-88]
+        _ = x[IBS_PREVENTHOST-89]
+        _ = x[IBS_ZEN4-90]
+        _ = x[IDPRED_CTRL-91]
+        _ = x[INT_WBINVD-92]
+        _ = x[INVLPGB-93]
+        _ = x[KEYLOCKER-94]
+        _ = x[KEYLOCKERW-95]
+        _ = x[LAHF-96]
+        _ = x[LAM-97]
+        _ = x[LBRVIRT-98]
+        _ = x[LZCNT-99]
+        _ = x[MCAOVERFLOW-100]
+        _ = x[MCDT_NO-101]
+        _ = x[MCOMMIT-102]
+        _ = x[MD_CLEAR-103]
+        _ = x[MMX-104]
+        _ = x[MMXEXT-105]
+        _ = x[MOVBE-106]
+        _ = x[MOVDIR64B-107]
+        _ = x[MOVDIRI-108]
+        _ = x[MOVSB_ZL-109]
+        _ = x[MOVU-110]
+        _ = x[MPX-111]
+        _ = x[MSRIRC-112]
+        _ = x[MSRLIST-113]
+        _ = x[MSR_PAGEFLUSH-114]
+        _ = x[NRIPS-115]
+        _ = x[NX-116]
+        _ = x[OSXSAVE-117]
+        _ = x[PCONFIG-118]
+        _ = x[POPCNT-119]
+        _ = x[PPIN-120]
+        _ = x[PREFETCHI-121]
+        _ = x[PSFD-122]
+        _ = x[RDPRU-123]
+        _ = x[RDRAND-124]
+        _ = x[RDSEED-125]
+        _ = x[RDTSCP-126]
+        _ = x[RRSBA_CTRL-127]
+        _ = x[RTM-128]
+        _ = x[RTM_ALWAYS_ABORT-129]
+        _ = x[SERIALIZE-130]
+        _ = x[SEV-131]
+        _ = x[SEV_64BIT-132]
+        _ = x[SEV_ALTERNATIVE-133]
+        _ = x[SEV_DEBUGSWAP-134]
+        _ = x[SEV_ES-135]
+        _ = x[SEV_RESTRICTED-136]
+        _ = x[SEV_SNP-137]
+        _ = x[SGX-138]
+        _ = x[SGXLC-139]
+        _ = x[SHA-140]
+        _ = x[SME-141]
+        _ = x[SME_COHERENT-142]
+        _ = x[SPEC_CTRL_SSBD-143]
+        _ = x[SRBDS_CTRL-144]
+        _ = x[SSE-145]
+        _ = x[SSE2-146]
+        _ = x[SSE3-147]
+        _ = x[SSE4-148]
+        _ = x[SSE42-149]
+        _ = x[SSE4A-150]
+        _ = x[SSSE3-151]
+        _ = x[STIBP-152]
+        _ = x[STIBP_ALWAYSON-153]
+        _ = x[STOSB_SHORT-154]
+        _ = x[SUCCOR-155]
+        _ = x[SVM-156]
+        _ = x[SVMDA-157]
+        _ = x[SVMFBASID-158]
+        _ = x[SVML-159]
+        _ = x[SVMNP-160]
+        _ = x[SVMPF-161]
+        _ = x[SVMPFT-162]
+        _ = x[SYSCALL-163]
+        _ = x[SYSEE-164]
+        _ = x[TBM-165]
+        _ = x[TDX_GUEST-166]
+        _ = x[TLB_FLUSH_NESTED-167]
+        _ = x[TME-168]
+        _ = x[TOPEXT-169]
+        _ = x[TSCRATEMSR-170]
+        _ = x[TSXLDTRK-171]
+        _ = x[VAES-172]
+        _ = x[VMCBCLEAN-173]
+        _ = x[VMPL-174]
+        _ = x[VMSA_REGPROT-175]
+        _ = x[VMX-176]
+        _ = x[VPCLMULQDQ-177]
+        _ = x[VTE-178]
+        _ = x[WAITPKG-179]
+        _ = x[WBNOINVD-180]
+        _ = x[WRMSRNS-181]
+        _ = x[X87-182]
+        _ = x[XGETBV1-183]
+        _ = x[XOP-184]
+        _ = x[XSAVE-185]
+        _ = x[XSAVEC-186]
+        _ = x[XSAVEOPT-187]
+        _ = x[XSAVES-188]
+        _ = x[AESARM-189]
+        _ = x[ARMCPUID-190]
+        _ = x[ASIMD-191]
+        _ = x[ASIMDDP-192]
+        _ = x[ASIMDHP-193]
+        _ = x[ASIMDRDM-194]
+        _ = x[ATOMICS-195]
+        _ = x[CRC32-196]
+        _ = x[DCPOP-197]
+        _ = x[EVTSTRM-198]
+        _ = x[FCMA-199]
+        _ = x[FP-200]
+        _ = x[FPHP-201]
+        _ = x[GPA-202]
+        _ = x[JSCVT-203]
+        _ = x[LRCPC-204]
+        _ = x[PMULL-205]
+        _ = x[SHA1-206]
+        _ = x[SHA2-207]
+        _ = x[SHA3-208]
+        _ = x[SHA512-209]
+        _ = x[SM3-210]
+        _ = x[SM4-211]
+        _ = x[SVE-212]
+        _ = x[lastID-213]
+        _ = x[firstID-0]
+}
+
+const _FeatureID_name = "firstIDADXAESNIAMD3DNOWAMD3DNOWEXTAMXBF16AMXFP16AMXINT8AMXTILEAPX_FAVXAVX10AVX10_128AVX10_256AVX10_512AVX2AVX512BF16AVX512BITALGAVX512BWAVX512CDAVX512DQAVX512ERAVX512FAVX512FP16AVX512IFMAAVX512PFAVX512VBMIAVX512VBMI2AVX512VLAVX512VNNIAVX512VP2INTERSECTAVX512VPOPCNTDQAVXIFMAAVXNECONVERTAVXSLOWAVXVNNIAVXVNNIINT8BHI_CTRLBMI1BMI2CETIBTCETSSCLDEMOTECLMULCLZEROCMOVCMPCCXADDCMPSB_SCADBS_SHORTCMPXCHG8CPBOOSTCPPCCX16EFER_LMSLE_UNSENQCMDERMSF16CFLUSH_L1DFMA3FMA4FP128FP256FSRMFXSRFXSROPTGFNIHLEHRESETHTTHWAHYBRID_CPUHYPERVISORIA32_ARCH_CAPIA32_CORE_CAPIBPBIBRSIBRS_PREFERREDIBRS_PROVIDES_SMPIBSIBSBRNTRGTIBSFETCHSAMIBSFFVIBSOPCNTIBSOPCNTEXTIBSOPSAMIBSRDWROPCNTIBSRIPINVALIDCHKIBS_FETCH_CTLXIBS_OPDATA4IBS_OPFUSEIBS_PREVENTHOSTIBS_ZEN4IDPRED_CTRLINT_WBINVDINVLPGBKEYLOCKERKEYLOCKERWLAHFLAMLBRVIRTLZCNTMCAOVERFLOWMCDT_NOMCOMMITMD_CLEARMMXMMXEXTMOVBEMOVDIR64BMOVDIRIMOVSB_ZLMOVUMPXMSRIRCMSRLISTMSR_PAGEFLUSHNRIPSNXOSXSAVEPCONFIGPOPCNTPPINPREFETCHIPSFDRDPRURDRANDRDSEEDRDTSCPRRSBA_CTRLRTMRTM_ALWAYS_ABORTSERIALIZESEVSEV_64BITSEV_ALTERNATIVESEV_DEBUGSWAPSEV_ESSEV_RESTRICTEDSEV_SNPSGXSGXLCSHASMESME_COHERENTSPEC_CTRL_SSBDSRBDS_CTRLSSESSE2SSE3SSE4SSE42SSE4ASSSE3STIBPSTIBP_ALWAYSONSTOSB_SHORTSUCCORSVMSVMDASVMFBASIDSVMLSVMNPSVMPFSVMPFTSYSCALLSYSEETBMTDX_GUESTTLB_FLUSH_NESTEDTMETOPEXTTSCRATEMSRTSXLDTRKVAESVMCBCLEANVMPLVMSA_REGPROTVMXVPCLMULQDQVTEWAITPKGWBNOINVDWRMSRNSX87XGETBV1XOPXSAVEXSAVECXSAVEOPTXSAVESAESARMARMCPUIDASIMDASIMDDPASIMDHPASIMDRDMATOMICSCRC32DCPOPEVTSTRMFCMAFPFPHPGPAJSCVTLRCPCPMULLSHA1SHA2SHA3SHA512SM3SM4SVElastID"
+
+var _FeatureID_index = [...]uint16{0, 7, 10, 15, 23, 34, 41, 48, 55, 62, 67, 70, 75, 84, 93, 102, 106, 116, 128, 136, 144, 152, 160, 167, 177, 187, 195, 205, 216, 224, 234, 252, 267, 274, 286, 293, 300, 311, 319, 323, 327, 333, 338, 346, 351, 357, 361, 370, 388, 396, 403, 407, 411, 425, 431, 435, 439, 448, 452, 456, 461, 466, 470, 474, 481, 485, 488, 494, 497, 500, 510, 520, 533, 546, 550, 554, 568, 585, 588, 598, 609, 615, 623, 634, 642, 654, 670, 684, 695, 705, 720, 728, 739, 749, 756, 765, 775, 779, 782, 789, 794, 805, 812, 819, 827, 830, 836, 841, 850, 857, 865, 869, 872, 878, 885, 898, 903, 905, 912, 919, 925, 929, 938, 942, 947, 953, 959, 965, 975, 978, 994, 1003, 1006, 1015, 1030, 1043, 1049, 1063, 1070, 1073, 1078, 1081, 1084, 1096, 1110, 1120, 1123, 1127, 1131, 1135, 1140, 1145, 1150, 1155, 1169, 1180, 1186, 1189, 1194, 1203, 1207, 1212, 1217, 1223, 1230, 1235, 1238, 1247, 1263, 1266, 1272, 1282, 1290, 1294, 1303, 1307, 1319, 1322, 1332, 1335, 1342, 1350, 1357, 1360, 1367, 1370, 1375, 1381, 1389, 1395, 1401, 1409, 1414, 1421, 1428, 1436, 1443, 1448, 1453, 1460, 1464, 1466, 1470, 1473, 1478, 1483, 1488, 1492, 1496, 1500, 1506, 1509, 1512, 1515, 1521}
+
+func (i FeatureID) String() string {
+        if i < 0 || i >= FeatureID(len(_FeatureID_index)-1) {
+                return "FeatureID(" + strconv.FormatInt(int64(i), 10) + ")"
+        }
+        return _FeatureID_name[_FeatureID_index[i]:_FeatureID_index[i+1]]
+}
+func _() {
+        // An "invalid array index" compiler error signifies that the constant values have changed.
+        // Re-run the stringer command to generate them again.
+        var x [1]struct{}
+        _ = x[VendorUnknown-0]
+        _ = x[Intel-1]
+        _ = x[AMD-2]
+        _ = x[VIA-3]
+        _ = x[Transmeta-4]
+        _ = x[NSC-5]
+        _ = x[KVM-6]
+        _ = x[MSVM-7]
+        _ = x[VMware-8]
+        _ = x[XenHVM-9]
+        _ = x[Bhyve-10]
+        _ = x[Hygon-11]
+        _ = x[SiS-12]
+        _ = x[RDC-13]
+        _ = x[Ampere-14]
+        _ = x[ARM-15]
+        _ = x[Broadcom-16]
+        _ = x[Cavium-17]
+        _ = x[DEC-18]
+        _ = x[Fujitsu-19]
+        _ = x[Infineon-20]
+        _ = x[Motorola-21]
+        _ = x[NVIDIA-22]
+        _ = x[AMCC-23]
+        _ = x[Qualcomm-24]
+        _ = x[Marvell-25]
+        _ = x[lastVendor-26]
+}
+
+const _Vendor_name = "VendorUnknownIntelAMDVIATransmetaNSCKVMMSVMVMwareXenHVMBhyveHygonSiSRDCAmpereARMBroadcomCaviumDECFujitsuInfineonMotorolaNVIDIAAMCCQualcommMarvelllastVendor"
+
+var _Vendor_index = [...]uint8{0, 13, 18, 21, 24, 33, 36, 39, 43, 49, 55, 60, 65, 68, 71, 77, 80, 88, 94, 97, 104, 112, 120, 126, 130, 138, 145, 155}
+
+func (i Vendor) String() string {
+        if i < 0 || i >= Vendor(len(_Vendor_index)-1) {
+                return "Vendor(" + strconv.FormatInt(int64(i), 10) + ")"
+        }
+        return _Vendor_name[_Vendor_index[i]:_Vendor_index[i+1]]
+}
diff --git a/vendor/github.com/klauspost/cpuid/v2/os_darwin_arm64.go b/vendor/github.com/klauspost/cpuid/v2/os_darwin_arm64.go
new file mode 100644
index 0000000..84b1acd
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/os_darwin_arm64.go
@@ -0,0 +1,121 @@
+// Copyright (c) 2020 Klaus Post, released under MIT License. See LICENSE file.
+
+package cpuid
+
+import (
+        "runtime"
+        "strings"
+
+        "golang.org/x/sys/unix"
+)
+
+func detectOS(c *CPUInfo) bool {
+        if runtime.GOOS != "ios" {
+                tryToFillCPUInfoFomSysctl(c)
+        }
+        // There are no hw.optional sysctl values for the below features on Mac OS 11.0
+        // to detect their supported state dynamically. Assume the CPU features that
+        // Apple Silicon M1 supports to be available as a minimal set of features
+        // to all Go programs running on darwin/arm64.
+        // TODO: Add more if we know them.
+        c.featureSet.setIf(runtime.GOOS != "ios", AESARM, PMULL, SHA1, SHA2)
+
+        return true
+}
+
+func sysctlGetBool(name string) bool {
+        value, err := unix.SysctlUint32(name)
+        if err != nil {
+                return false
+        }
+        return value != 0
+}
+
+func sysctlGetString(name string) string {
+        value, err := unix.Sysctl(name)
+        if err != nil {
+                return ""
+        }
+        return value
+}
+
+func sysctlGetInt(unknown int, names ...string) int {
+        for _, name := range names {
+                value, err := unix.SysctlUint32(name)
+                if err != nil {
+                        continue
+                }
+                if value != 0 {
+                        return int(value)
+                }
+        }
+        return unknown
+}
+
+func sysctlGetInt64(unknown int, names ...string) int {
+        for _, name := range names {
+                value64, err := unix.SysctlUint64(name)
+                if err != nil {
+                        continue
+                }
+                if int(value64) != unknown {
+                        return int(value64)
+                }
+        }
+        return unknown
+}
+
+func setFeature(c *CPUInfo, name string, feature FeatureID) {
+        c.featureSet.setIf(sysctlGetBool(name), feature)
+}
+func tryToFillCPUInfoFomSysctl(c *CPUInfo) {
+        c.BrandName = sysctlGetString("machdep.cpu.brand_string")
+
+        if len(c.BrandName) != 0 {
+                c.VendorString = strings.Fields(c.BrandName)[0]
+        }
+
+        c.PhysicalCores = sysctlGetInt(runtime.NumCPU(), "hw.physicalcpu")
+        c.ThreadsPerCore = sysctlGetInt(1, "machdep.cpu.thread_count", "kern.num_threads") /
+                sysctlGetInt(1, "hw.physicalcpu")
+        c.LogicalCores = sysctlGetInt(runtime.NumCPU(), "machdep.cpu.core_count")
+        c.Family = sysctlGetInt(0, "machdep.cpu.family", "hw.cpufamily")
+        c.Model = sysctlGetInt(0, "machdep.cpu.model")
+        c.CacheLine = sysctlGetInt64(0, "hw.cachelinesize")
+        c.Cache.L1I = sysctlGetInt64(-1, "hw.l1icachesize")
+        c.Cache.L1D = sysctlGetInt64(-1, "hw.l1dcachesize")
+        c.Cache.L2 = sysctlGetInt64(-1, "hw.l2cachesize")
+        c.Cache.L3 = sysctlGetInt64(-1, "hw.l3cachesize")
+
+        // from https://developer.arm.com/downloads/-/exploration-tools/feature-names-for-a-profile
+        setFeature(c, "hw.optional.arm.FEAT_AES", AESARM)
+        setFeature(c, "hw.optional.AdvSIMD", ASIMD)
+        setFeature(c, "hw.optional.arm.FEAT_DotProd", ASIMDDP)
+        setFeature(c, "hw.optional.arm.FEAT_RDM", ASIMDRDM)
+        setFeature(c, "hw.optional.FEAT_CRC32", CRC32)
+        setFeature(c, "hw.optional.arm.FEAT_DPB", DCPOP)
+        // setFeature(c, "", EVTSTRM)
+        setFeature(c, "hw.optional.arm.FEAT_FCMA", FCMA)
+        setFeature(c, "hw.optional.arm.FEAT_FP", FP)
+        setFeature(c, "hw.optional.arm.FEAT_FP16", FPHP)
+        setFeature(c, "hw.optional.arm.FEAT_PAuth", GPA)
+        setFeature(c, "hw.optional.arm.FEAT_JSCVT", JSCVT)
+        setFeature(c, "hw.optional.arm.FEAT_LRCPC", LRCPC)
+        setFeature(c, "hw.optional.arm.FEAT_PMULL", PMULL)
+        setFeature(c, "hw.optional.arm.FEAT_SHA1", SHA1)
+        setFeature(c, "hw.optional.arm.FEAT_SHA256", SHA2)
+        setFeature(c, "hw.optional.arm.FEAT_SHA3", SHA3)
+        setFeature(c, "hw.optional.arm.FEAT_SHA512", SHA512)
+        // setFeature(c, "", SM3)
+        // setFeature(c, "", SM4)
+        setFeature(c, "hw.optional.arm.FEAT_SVE", SVE)
+
+        // from empirical observation
+        setFeature(c, "hw.optional.AdvSIMD_HPFPCvt", ASIMDHP)
+        setFeature(c, "hw.optional.armv8_1_atomics", ATOMICS)
+        setFeature(c, "hw.optional.floatingpoint", FP)
+        setFeature(c, "hw.optional.armv8_2_sha3", SHA3)
+        setFeature(c, "hw.optional.armv8_2_sha512", SHA512)
+        setFeature(c, "hw.optional.armv8_3_compnum", FCMA)
+        setFeature(c, "hw.optional.armv8_crc32", CRC32)
+}
diff --git a/vendor/github.com/klauspost/cpuid/v2/os_linux_arm64.go b/vendor/github.com/klauspost/cpuid/v2/os_linux_arm64.go
new file mode 100644
index 0000000..ee278b9
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/os_linux_arm64.go
@@ -0,0 +1,130 @@
+// Copyright (c) 2020 Klaus Post, released under MIT License. See LICENSE file.
+
+// Copyright 2018 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 located
+// here https://github.com/golang/sys/blob/master/LICENSE
+
+package cpuid
+
+import (
+        "encoding/binary"
+        "io/ioutil"
+        "runtime"
+)
+
+// HWCAP bits.
+const (
+        hwcap_FP       = 1 << 0
+        hwcap_ASIMD    = 1 << 1
+        hwcap_EVTSTRM  = 1 << 2
+        hwcap_AES      = 1 << 3
+        hwcap_PMULL    = 1 << 4
+        hwcap_SHA1     = 1 << 5
+        hwcap_SHA2     = 1 << 6
+        hwcap_CRC32    = 1 << 7
+        hwcap_ATOMICS  = 1 << 8
+        hwcap_FPHP     = 1 << 9
+        hwcap_ASIMDHP  = 1 << 10
+        hwcap_CPUID    = 1 << 11
+        hwcap_ASIMDRDM = 1 << 12
+        hwcap_JSCVT    = 1 << 13
+        hwcap_FCMA     = 1 << 14
+        hwcap_LRCPC    = 1 << 15
+        hwcap_DCPOP    = 1 << 16
+        hwcap_SHA3     = 1 << 17
+        hwcap_SM3      = 1 << 18
+        hwcap_SM4      = 1 << 19
+        hwcap_ASIMDDP  = 1 << 20
+        hwcap_SHA512   = 1 << 21
+        hwcap_SVE      = 1 << 22
+        hwcap_ASIMDFHM = 1 << 23
+)
+
+func detectOS(c *CPUInfo) bool {
+        // For now assuming no hyperthreading is reasonable.
+        c.LogicalCores = runtime.NumCPU()
+        c.PhysicalCores = c.LogicalCores
+        c.ThreadsPerCore = 1
+        if hwcap == 0 {
+                // We did not get values from the runtime.
+                // Try reading /proc/self/auxv
+
+                // From https://github.com/golang/sys
+                const (
+                        _AT_HWCAP  = 16
+                        _AT_HWCAP2 = 26
+
+                        uintSize = int(32 << (^uint(0) >> 63))
+                )
+
+                buf, err := ioutil.ReadFile("/proc/self/auxv")
+                if err != nil {
+                        // e.g. on android /proc/self/auxv is not accessible, so silently
+                        // ignore the error and leave Initialized = false. On some
+                        // architectures (e.g. arm64) doinit() implements a fallback
+                        // readout and will set Initialized = true again.
+                        return false
+                }
+                bo := binary.LittleEndian
+                for len(buf) >= 2*(uintSize/8) {
+                        var tag, val uint
+                        switch uintSize {
+                        case 32:
+                                tag = uint(bo.Uint32(buf[0:]))
+                                val = uint(bo.Uint32(buf[4:]))
+                                buf = buf[8:]
+                        case 64:
+                                tag = uint(bo.Uint64(buf[0:]))
+                                val = uint(bo.Uint64(buf[8:]))
+                                buf = buf[16:]
+                        }
+                        switch tag {
+                        case _AT_HWCAP:
+                                hwcap = val
+                        case _AT_HWCAP2:
+                                // Not used
+                        }
+                }
+                if hwcap == 0 {
+                        return false
+                }
+        }
+
+        // HWCap was populated by the runtime from the auxiliary vector.
+        // Use HWCap information since reading aarch64 system registers
+        // is not supported in user space on older linux kernels.
+        c.featureSet.setIf(isSet(hwcap, hwcap_AES), AESARM)
+        c.featureSet.setIf(isSet(hwcap, hwcap_ASIMD), ASIMD)
+        c.featureSet.setIf(isSet(hwcap, hwcap_ASIMDDP), ASIMDDP)
+        c.featureSet.setIf(isSet(hwcap, hwcap_ASIMDHP), ASIMDHP)
+        c.featureSet.setIf(isSet(hwcap, hwcap_ASIMDRDM), ASIMDRDM)
+        c.featureSet.setIf(isSet(hwcap, hwcap_CPUID), ARMCPUID)
+        c.featureSet.setIf(isSet(hwcap, hwcap_CRC32), CRC32)
+        c.featureSet.setIf(isSet(hwcap, hwcap_DCPOP), DCPOP)
+        c.featureSet.setIf(isSet(hwcap, hwcap_EVTSTRM), EVTSTRM)
+        c.featureSet.setIf(isSet(hwcap, hwcap_FCMA), FCMA)
+        c.featureSet.setIf(isSet(hwcap, hwcap_FP), FP)
+        c.featureSet.setIf(isSet(hwcap, hwcap_FPHP), FPHP)
+        c.featureSet.setIf(isSet(hwcap, hwcap_JSCVT), JSCVT)
+        c.featureSet.setIf(isSet(hwcap, hwcap_LRCPC), LRCPC)
+        c.featureSet.setIf(isSet(hwcap, hwcap_PMULL), PMULL)
+        c.featureSet.setIf(isSet(hwcap, hwcap_SHA1), SHA1)
+        c.featureSet.setIf(isSet(hwcap, hwcap_SHA2), SHA2)
+        c.featureSet.setIf(isSet(hwcap, hwcap_SHA3), SHA3)
+        c.featureSet.setIf(isSet(hwcap, hwcap_SHA512), SHA512)
+        c.featureSet.setIf(isSet(hwcap, hwcap_SM3), SM3)
+        c.featureSet.setIf(isSet(hwcap, hwcap_SM4), SM4)
+        c.featureSet.setIf(isSet(hwcap, hwcap_SVE), SVE)
+
+        // The Samsung S9+ kernel reports support for atomics, but not all cores
+        // actually support them, resulting in SIGILL. See issue #28431.
+        // TODO(elias.naur): Only disable the optimization on bad chipsets on android.
+        c.featureSet.setIf(isSet(hwcap, hwcap_ATOMICS) && runtime.GOOS != "android", ATOMICS)
+
+        return true
+}
+
+func isSet(hwc uint, value uint) bool {
+        return hwc&value != 0
+}
diff --git a/vendor/github.com/klauspost/cpuid/v2/os_other_arm64.go b/vendor/github.com/klauspost/cpuid/v2/os_other_arm64.go
new file mode 100644
index 0000000..8733ba3
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/os_other_arm64.go
@@ -0,0 +1,16 @@
+// Copyright (c) 2020 Klaus Post, released under MIT License. See LICENSE file.
+
+//go:build arm64 && !linux && !darwin
+// +build arm64,!linux,!darwin
+
+package cpuid
+
+import "runtime"
+
+func detectOS(c *CPUInfo) bool {
+        c.PhysicalCores = runtime.NumCPU()
+        // For now assuming 1 thread per core...
+        c.ThreadsPerCore = 1
+        c.LogicalCores = c.PhysicalCores
+        return false
+}
diff --git a/vendor/github.com/klauspost/cpuid/v2/os_safe_linux_arm64.go b/vendor/github.com/klauspost/cpuid/v2/os_safe_linux_arm64.go
new file mode 100644
index 0000000..f8f201b
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/os_safe_linux_arm64.go
@@ -0,0 +1,8 @@
+// Copyright (c) 2021 Klaus Post, released under MIT License. See LICENSE file.
+
+//go:build nounsafe
+// +build nounsafe
+
+package cpuid
+
+var hwcap uint
diff --git a/vendor/github.com/klauspost/cpuid/v2/os_unsafe_linux_arm64.go b/vendor/github.com/klauspost/cpuid/v2/os_unsafe_linux_arm64.go
new file mode 100644
index 0000000..92af622
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/os_unsafe_linux_arm64.go
@@ -0,0 +1,11 @@
+// Copyright (c) 2021 Klaus Post, released under MIT License. See LICENSE file.
+
+//go:build !nounsafe
+// +build !nounsafe
+
+package cpuid
+
+import _ "unsafe" // needed for go:linkname
+
+//go:linkname hwcap internal/cpu.HWCap
+var hwcap uint
diff --git a/vendor/github.com/klauspost/cpuid/v2/test-architectures.sh b/vendor/github.com/klauspost/cpuid/v2/test-architectures.sh
new file mode 100644
index 0000000..471d986
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/v2/test-architectures.sh
@@ -0,0 +1,15 @@
+#!/bin/sh
+
+set -e
+
+go tool dist list | while IFS=/ read os arch; do
+    echo "Checking $os/$arch..."
+    echo " normal"
+    GOARCH=$arch GOOS=$os go build -o /dev/null .
+    echo " noasm"
+    GOARCH=$arch GOOS=$os go build -tags noasm -o /dev/null .
+    echo " appengine"
+    GOARCH=$arch GOOS=$os go build -tags appengine -o /dev/null .
+    echo " noasm,appengine"
+    GOARCH=$arch GOOS=$os go build -tags 'appengine noasm' -o /dev/null .
+done
diff --git a/vendor/github.com/minio/md5-simd/LICENSE b/vendor/github.com/minio/md5-simd/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/vendor/github.com/minio/md5-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.
diff --git a/vendor/github.com/minio/md5-simd/LICENSE.Golang b/vendor/github.com/minio/md5-simd/LICENSE.Golang
new file mode 100644
index 0000000..6a66aea
--- /dev/null
+++ b/vendor/github.com/minio/md5-simd/LICENSE.Golang
@@ -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.
diff --git a/vendor/github.com/minio/md5-simd/README.md b/vendor/github.com/minio/md5-simd/README.md
new file mode 100644
index 0000000..fa6fce1
--- /dev/null
+++ b/vendor/github.com/minio/md5-simd/README.md
@@ -0,0 +1,198 @@
+
+# md5-simd
+
+This is a SIMD accelerated MD5 package, allowing up to either 8 (AVX2) or 16 (AVX512) independent MD5 sums to be calculated on a single CPU core.
+
+It was originally based on the [md5vec](https://github.com/igneous-systems/md5vec) repository by Igneous Systems, but has been made more flexible by amongst others supporting different message sizes per lane and adding AVX512.
+
+`md5-simd` integrates a similar mechanism as described in [minio/sha256-simd](https://github.com/minio/sha256-simd#support-for-avx512) for making it easy for clients to take advantages of the parallel nature of the MD5 calculation. This will result in reduced overall CPU load. 
+
+It is important to understand that `md5-simd` **does not speed up** a single threaded MD5 hash sum. 
+Rather it allows multiple __independent__  MD5 sums to be computed in parallel on the same CPU core, 
+thereby making more efficient usage of the computing resources.
+
+## Usage
+
+[![Documentation](https://godoc.org/github.com/minio/md5-simd?status.svg)](https://pkg.go.dev/github.com/minio/md5-simd?tab=doc)
+
+
+In order to use `md5-simd`, you must first create an `Server` which can be 
+used to instantiate one or more objects for MD5 hashing. 
+
+These objects conform to the regular [`hash.Hash`](https://pkg.go.dev/hash?tab=doc#Hash) interface 
+and as such the normal Write/Reset/Sum functionality works as expected. 
+
+As an example: 
+```
+    // Create server
+    server := md5simd.NewServer()
+    defer server.Close()
+
+    // Create hashing object (conforming to hash.Hash)
+    md5Hash := server.NewHash()
+    defer md5Hash.Close()
+
+    // Write one (or more) blocks
+    md5Hash.Write(block)
+    
+    // Return digest
+    digest := md5Hash.Sum([]byte{})
+```
+
+To keep performance both a [Server](https://pkg.go.dev/github.com/minio/md5-simd?tab=doc#Server) 
+and individual [Hasher](https://pkg.go.dev/github.com/minio/md5-simd?tab=doc#Hasher) should 
+be closed using the `Close()` function when no longer needed.
+
+A Hasher can efficiently be re-used by using [`Reset()`](https://pkg.go.dev/hash?tab=doc#Hash) functionality.
+
+In case your system does not support the instructions required it will fall back to using `crypto/md5` for hashing.
+
+## Limitations
+
+As explained above `md5-simd` does not speed up an individual MD5 hash sum computation,
+unless some hierarchical tree construct is used but this will result in different outcomes.
+Running a single hash on a server results in approximately half the throughput.
+
+Instead, it allows running multiple MD5 calculations in parallel on a single CPU core. 
+This can be beneficial in e.g. multi-threaded server applications where many go-routines 
+are dealing with many requests and multiple MD5 calculations can be packed/scheduled for parallel execution on a single core.
+
+This will result in a lower overall CPU usage as compared to using the standard `crypto/md5`
+functionality where each MD5 hash computation will consume a single thread (core).
+
+It is best to test and measure the overall CPU usage in a representative usage scenario in your application
+to get an overall understanding of the benefits of `md5-simd` as compared to `crypto/md5`, ideally under heavy CPU load.
+
+Also note that `md5-simd` is best meant to work with large objects, 
+so if your application only hashes small objects of a few kilobytes 
+you may be better of by using `crypto/md5`.
+
+## Performance
+
+For the best performance writes should be a multiple of 64 bytes, ideally a multiple of 32KB.
+To help with that a [`buffered := bufio.NewWriterSize(hasher, 32<<10)`](https://golang.org/pkg/bufio/#NewWriterSize) 
+can be inserted if you are unsure of the sizes of the writes. 
+Remember to [flush](https://golang.org/pkg/bufio/#Writer.Flush) `buffered` before reading the hash. 
+
+A single 'server' can process 16 streams concurrently with 1 core (AVX-512) or 2 cores (AVX2). 
+In situations where it is likely that more than 16 streams are fully loaded it may be beneficial
+to use multiple servers.
+
+The following chart compares the multi-core performance between `crypto/md5` vs the AVX2 vs the AVX512 code:
+
+![md5-performance-overview](chart/Multi-core-MD5-Aggregated-Hashing-Performance.png)
+
+Compared to `crypto/md5`, the AVX2 version is up to 4x faster:
+
+```
+$ benchcmp crypto-md5.txt avx2.txt 
+benchmark                     old MB/s     new MB/s     speedup
+BenchmarkParallel/32KB-4      2229.22      7370.50      3.31x
+BenchmarkParallel/64KB-4      2233.61      8248.46      3.69x
+BenchmarkParallel/128KB-4     2235.43      8660.74      3.87x
+BenchmarkParallel/256KB-4     2236.39      8863.87      3.96x
+BenchmarkParallel/512KB-4     2238.05      8985.39      4.01x
+BenchmarkParallel/1MB-4       2233.56      9042.62      4.05x
+BenchmarkParallel/2MB-4       2224.11      9014.46      4.05x
+BenchmarkParallel/4MB-4       2199.78      8993.61      4.09x
+BenchmarkParallel/8MB-4       2182.48      8748.22      4.01x
+```
+
+Compared to `crypto/md5`, the AVX512 is up to 8x faster (for larger block sizes):
+
+```
+$ benchcmp crypto-md5.txt avx512.txt
+benchmark                     old MB/s     new MB/s     speedup
+BenchmarkParallel/32KB-4      2229.22      11605.78     5.21x
+BenchmarkParallel/64KB-4      2233.61      14329.65     6.42x
+BenchmarkParallel/128KB-4     2235.43      16166.39     7.23x
+BenchmarkParallel/256KB-4     2236.39      15570.09     6.96x
+BenchmarkParallel/512KB-4     2238.05      16705.83     7.46x
+BenchmarkParallel/1MB-4       2233.56      16941.95     7.59x
+BenchmarkParallel/2MB-4       2224.11      17136.01     7.70x
+BenchmarkParallel/4MB-4       2199.78      17218.61     7.83x
+BenchmarkParallel/8MB-4       2182.48      17252.88     7.91x
+```
+
+These measurements were performed on AWS EC2 instance of type `c5.xlarge` equipped with a Xeon Platinum 8124M CPU at 3.0 GHz.
+
+If only one or two inputs are available the scalar calculation method will be used for the 
+optimal speed in these cases.
+
+## Operation
+
+To make operation as easy as possible there is a “Server” coordinating everything. The server keeps track of individual hash states and updates them as new data comes in. This can be visualized as follows:
+
+![server-architecture](chart/server-architecture.png)
+
+The data is sent to the server from each hash input in blocks of up to 32KB per round. In our testing we found this to be the block size that yielded the best results.
+
+Whenever there is data available the server will collect data for up to 16 hashes and process all 16 lanes in parallel. This means that if 16 hashes have data available all the lanes will be filled. However since that may not be the case, the server will fill less lanes and do a round anyway. Lanes can also be partially filled if less than 32KB of data is written.
+
+![server-lanes-example](chart/server-lanes-example.png)
+
+In this example 4 lanes are fully filled and 2 lanes are partially filled. In this case the black areas will simply be masked out from the results and ignored. This is also why calculating a single hash on a server will not result in any speedup and hash writes should be a multiple of 32KB for the best performance.
+
+For AVX512 all 16 calculations will be done on a single core, on AVX2 on 2 cores if there is data for more than 8 lanes.
+So for optimal usage there should be data available for all 16 hashes. It may be perfectly reasonable to use more than 16 concurrent hashes.
+
+
+## Design & Tech
+
+md5-simd has both an AVX2 (8-lane parallel), and an AVX512 (16-lane parallel version) algorithm to accelerate the computation with the following function definitions:
+```
+//go:noescape
+func block8(state *uint32, base uintptr, bufs *int32, cache *byte, n int)
+
+//go:noescape
+func block16(state *uint32, ptrs *int64, mask uint64, n int)
+```
+
+The AVX2 version is based on the [md5vec](https://github.com/igneous-systems/md5vec) repository and is essentially unchanged except for minor (cosmetic) changes.
+
+The AVX512 version is derived from the AVX2 version but adds some further optimizations and simplifications.
+
+### Caching in upper ZMM registers
+
+The AVX2 version passes in a `cache8` block of memory (about 0.5 KB) for temporary storage of intermediate results during `ROUND1` which are subsequently used during `ROUND2` through to `ROUND4`.
+
+Since AVX512 has double the amount of registers (32 ZMM registers as compared to 16 YMM registers), it is possible to use the upper 16 ZMM registers for keeping the intermediate states on the CPU. As such, there is no need to pass in a corresponding `cache16` into the AVX512 block function.
+
+### Direct loading using 64-bit pointers
+
+The AVX2 uses the `VPGATHERDD` instruction (for YMM) to do a parallel load of 8 lanes using (8 independent) 32-bit offets. Since there is no control over how the 8 slices that are passed into the (Golang) `blockMd5` function are laid out into memory, it is not possible to derive a "base" address and corresponding offsets (all within 32-bits) for all 8 slices.
+
+As such the AVX2 version uses an interim buffer to collect the byte slices to be hashed from all 8 inut slices and passed this buffer along with (fixed) 32-bit offsets into the assembly code.
+
+For the AVX512 version this interim buffer is not needed since the AVX512 code uses a pair of `VPGATHERQD` instructions to directly dereference 64-bit pointers (from a base register address that is initialized to zero).
+
+Note that two load (gather) instructions are needed because the AVX512 version processes 16-lanes in parallel, requiring 16 times 64-bit = 1024 bits in total to be loaded. A simple `VALIGND` and `VPORD` are subsequently used to merge the lower and upper halves together into a single ZMM register (that contains 16 lanes of 32-bit DWORDS).
+
+### Masking support
+
+Due to the fact that pointers are passed directly from the Golang slices, we need to protect against NULL pointers. 
+For this a 16-bit mask is passed in the AVX512 assembly code which is used during the `VPGATHERQD` instructions to mask out lanes that could otherwise result in segment violations.
+
+### Minor optimizations
+
+The `roll` macro (three instructions on AVX2) is no longer needed for AVX512 and is replaced by a single `VPROLD` instruction.
+
+Also several logical operations from the various ROUNDS of the AVX2 version could be combined into a single instruction using ternary logic (with the `VPTERMLOGD` instruction), resulting in a further simplification and speed-up.
+
+## Low level block function performance
+
+The benchmark below shows the (single thread) maximum performance of the `block()` function for AVX2 (having 8 lanes) and AVX512 (having 16 lanes). Also the baseline single-core performance from the standard `crypto/md5` package is shown for comparison.
+
+```
+BenchmarkCryptoMd5-4                     687.66 MB/s           0 B/op          0 allocs/op
+BenchmarkBlock8-4                       4144.80 MB/s           0 B/op          0 allocs/op
+BenchmarkBlock16-4                      8228.88 MB/s           0 B/op          0 allocs/op
+```
+
+## License
+
+`md5-simd` is 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.
\ No newline at end of file
diff --git a/vendor/github.com/minio/md5-simd/block16_amd64.s b/vendor/github.com/minio/md5-simd/block16_amd64.s
new file mode 100644
index 0000000..be0a43a
--- /dev/null
+++ b/vendor/github.com/minio/md5-simd/block16_amd64.s
@@ -0,0 +1,228 @@
+// Copyright (c) 2020 MinIO Inc. All rights reserved.
+// Use of this source code is governed by a license that can be
+// found in the LICENSE file.
+
+//+build !noasm,!appengine,gc
+
+// This is the AVX512 implementation of the MD5 block function (16-way parallel)
+
+#define prep(index) \
+        KMOVQ      kmask, ktmp                      \
+        VPGATHERDD index*4(base)(ptrs*1), ktmp, mem
+
+#define ROUND1(a, b, c, d, index, const, shift) \
+        VPXORQ     c, tmp, tmp            \
+        VPADDD     64*const(consts), a, a \
+        VPADDD     mem, a, a              \
+        VPTERNLOGD $0x6C, b, d, tmp       \
+        prep(index)                       \
+        VPADDD     tmp, a, a              \
+        VPROLD     $shift, a, a           \
+        VMOVAPD    c, tmp                 \
+        VPADDD     b, a, a
+
+#define ROUND1noload(a, b, c, d, const, shift) \
+        VPXORQ     c, tmp, tmp            \
+        VPADDD     64*const(consts), a, a \
+        VPADDD     mem, a, a              \
+        VPTERNLOGD $0x6C, b, d, tmp       \
+        VPADDD     tmp, a, a              \
+        VPROLD     $shift, a, a           \
+        VMOVAPD    c, tmp                 \
+        VPADDD     b, a, a
+
+#define ROUND2(a, b, c, d, zreg, const, shift) \
+        VPADDD     64*const(consts), a, a \
+        VPADDD     zreg, a, a             \
+        VANDNPD    c, tmp, tmp            \
+        VPTERNLOGD $0xEC, b, tmp, tmp2    \
+        VMOVAPD    c, tmp                 \
+        VPADDD     tmp2, a, a             \
+        VMOVAPD    c, tmp2                \
+        VPROLD     $shift, a, a           \
+        VPADDD     b, a, a
+
+#define ROUND3(a, b, c, d, zreg, const, shift) \
+        VPADDD     64*const(consts), a, a \
+        VPADDD     zreg, a, a             \
+        VPTERNLOGD $0x96, b, d, tmp       \
+        VPADDD     tmp, a, a              \
+        VPROLD     $shift, a, a           \
+        VMOVAPD    b, tmp                 \
+        VPADDD     b, a, a
+
+#define ROUND4(a, b, c, d, zreg, const, shift) \
+        VPADDD     64*const(consts), a, a \
+        VPADDD     zreg, a, a             \
+        VPTERNLOGD $0x36, b, c, tmp       \
+        VPADDD     tmp, a, a              \
+        VPROLD     $shift, a, a           \
+        VPXORQ     c, ones, tmp           \
+        VPADDD     b, a, a
+
+TEXT ·block16(SB), 4, $0-40
+
+        MOVQ  state+0(FP), BX
+        MOVQ  base+8(FP), SI
+        MOVQ  ptrs+16(FP), AX
+        KMOVQ mask+24(FP), K1
+        MOVQ  n+32(FP), DX
+        MOVQ  ·avx512md5consts+0(SB), DI
+
+#define a Z0
+#define b Z1
+#define c Z2
+#define d Z3
+
+#define sa Z4
+#define sb Z5
+#define sc Z6
+#define sd Z7
+
+#define tmp       Z8
+#define tmp2      Z9
+#define ptrs     Z10
+#define ones     Z12
+#define mem      Z15
+
+#define kmask  K1
+#define ktmp   K3
+
+// ----------------------------------------------------------
+// Registers Z16 through to Z31 are used for caching purposes
+// ----------------------------------------------------------
+
+#define dig    BX
+#define count  DX
+#define base   SI
+#define consts DI
+
+        // load digest into state registers
+        VMOVUPD (dig), a
+        VMOVUPD 0x40(dig), b
+        VMOVUPD 0x80(dig), c
+        VMOVUPD 0xc0(dig), d
+
+        // load source pointers
+        VMOVUPD 0x00(AX), ptrs
+
+        MOVQ         $-1, AX
+        VPBROADCASTQ AX, ones
+
+loop:
+        VMOVAPD a, sa
+        VMOVAPD b, sb
+        VMOVAPD c, sc
+        VMOVAPD d, sd
+
+        prep(0)
+        VMOVAPD d, tmp
+        VMOVAPD mem, Z16
+
+        ROUND1(a,b,c,d, 1,0x00, 7)
+        VMOVAPD mem, Z17
+        ROUND1(d,a,b,c, 2,0x01,12)
+        VMOVAPD mem, Z18
+        ROUND1(c,d,a,b, 3,0x02,17)
+        VMOVAPD mem, Z19
+        ROUND1(b,c,d,a, 4,0x03,22)
+        VMOVAPD mem, Z20
+        ROUND1(a,b,c,d, 5,0x04, 7)
+        VMOVAPD mem, Z21
+        ROUND1(d,a,b,c, 6,0x05,12)
+        VMOVAPD mem, Z22
+        ROUND1(c,d,a,b, 7,0x06,17)
+        VMOVAPD mem, Z23
+        ROUND1(b,c,d,a, 8,0x07,22)
+        VMOVAPD mem, Z24
+        ROUND1(a,b,c,d, 9,0x08, 7)
+        VMOVAPD mem, Z25
+        ROUND1(d,a,b,c,10,0x09,12)
+        VMOVAPD mem, Z26
+        ROUND1(c,d,a,b,11,0x0a,17)
+        VMOVAPD mem, Z27
+        ROUND1(b,c,d,a,12,0x0b,22)
+        VMOVAPD mem, Z28
+        ROUND1(a,b,c,d,13,0x0c, 7)
+        VMOVAPD mem, Z29
+        ROUND1(d,a,b,c,14,0x0d,12)
+        VMOVAPD mem, Z30
+        ROUND1(c,d,a,b,15,0x0e,17)
+        VMOVAPD mem, Z31
+
+        ROUND1noload(b,c,d,a, 0x0f,22)
+
+        VMOVAPD d, tmp
+        VMOVAPD d, tmp2
+
+        ROUND2(a,b,c,d, Z17,0x10, 5)
+        ROUND2(d,a,b,c, Z22,0x11, 9)
+        ROUND2(c,d,a,b, Z27,0x12,14)
+        ROUND2(b,c,d,a, Z16,0x13,20)
+        ROUND2(a,b,c,d, Z21,0x14, 5)
+        ROUND2(d,a,b,c, Z26,0x15, 9)
+        ROUND2(c,d,a,b, Z31,0x16,14)
+        ROUND2(b,c,d,a, Z20,0x17,20)
+        ROUND2(a,b,c,d, Z25,0x18, 5)
+        ROUND2(d,a,b,c, Z30,0x19, 9)
+        ROUND2(c,d,a,b, Z19,0x1a,14)
+        ROUND2(b,c,d,a, Z24,0x1b,20)
+        ROUND2(a,b,c,d, Z29,0x1c, 5)
+        ROUND2(d,a,b,c, Z18,0x1d, 9)
+        ROUND2(c,d,a,b, Z23,0x1e,14)
+        ROUND2(b,c,d,a, Z28,0x1f,20)
+
+        VMOVAPD c, tmp
+
+        ROUND3(a,b,c,d, Z21,0x20, 4)
+        ROUND3(d,a,b,c, Z24,0x21,11)
+        ROUND3(c,d,a,b, Z27,0x22,16)
+        ROUND3(b,c,d,a, Z30,0x23,23)
+        ROUND3(a,b,c,d, Z17,0x24, 4)
+        ROUND3(d,a,b,c, Z20,0x25,11)
+        ROUND3(c,d,a,b, Z23,0x26,16)
+        ROUND3(b,c,d,a, Z26,0x27,23)
+        ROUND3(a,b,c,d, Z29,0x28, 4)
+        ROUND3(d,a,b,c, Z16,0x29,11)
+        ROUND3(c,d,a,b, Z19,0x2a,16)
+        ROUND3(b,c,d,a, Z22,0x2b,23)
+        ROUND3(a,b,c,d, Z25,0x2c, 4)
+        ROUND3(d,a,b,c, Z28,0x2d,11)
+        ROUND3(c,d,a,b, Z31,0x2e,16)
+        ROUND3(b,c,d,a, Z18,0x2f,23)
+
+        VPXORQ d, ones, tmp
+
+        ROUND4(a,b,c,d, Z16,0x30, 6)
+        ROUND4(d,a,b,c, Z23,0x31,10)
+        ROUND4(c,d,a,b, Z30,0x32,15)
+        ROUND4(b,c,d,a, Z21,0x33,21)
+        ROUND4(a,b,c,d, Z28,0x34, 6)
+        ROUND4(d,a,b,c, Z19,0x35,10)
+        ROUND4(c,d,a,b, Z26,0x36,15)
+        ROUND4(b,c,d,a, Z17,0x37,21)
+        ROUND4(a,b,c,d, Z24,0x38, 6)
+        ROUND4(d,a,b,c, Z31,0x39,10)
+        ROUND4(c,d,a,b, Z22,0x3a,15)
+        ROUND4(b,c,d,a, Z29,0x3b,21)
+        ROUND4(a,b,c,d, Z20,0x3c, 6)
+        ROUND4(d,a,b,c, Z27,0x3d,10)
+        ROUND4(c,d,a,b, Z18,0x3e,15)
+        ROUND4(b,c,d,a, Z25,0x3f,21)
+
+        VPADDD sa, a, a
+        VPADDD sb, b, b
+        VPADDD sc, c, c
+        VPADDD sd, d, d
+
+        LEAQ 64(base), base
+        SUBQ $64, count
+        JNE  loop
+
+        VMOVUPD a, (dig)
+        VMOVUPD b, 0x40(dig)
+        VMOVUPD c, 0x80(dig)
+        VMOVUPD d, 0xc0(dig)
+
+        VZEROUPPER
+        RET
diff --git a/vendor/github.com/minio/md5-simd/block8_amd64.s b/vendor/github.com/minio/md5-simd/block8_amd64.s
new file mode 100644
index 0000000..f57db17
--- /dev/null
+++ b/vendor/github.com/minio/md5-simd/block8_amd64.s
@@ -0,0 +1,281 @@
+//+build !noasm,!appengine,gc
+
+// Copyright (c) 2018 Igneous Systems
+//   MIT License
+//
+//   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.
+
+// Copyright (c) 2020 MinIO Inc. All rights reserved.
+//   Use of this source code is governed by a license that can be
+//   found in the LICENSE file.
+
+// This is the AVX2 implementation of the MD5 block function (8-way parallel)
+
+// block8(state *uint64, base uintptr, bufs *int32, cache *byte, n int)
+TEXT ·block8(SB), 4, $0-40
+        MOVQ state+0(FP), BX
+        MOVQ base+8(FP), SI
+        MOVQ bufs+16(FP), AX
+        MOVQ cache+24(FP), CX
+        MOVQ n+32(FP), DX
+        MOVQ ·avx256md5consts+0(SB), DI
+
+        // Align cache (which is stack allocated by the compiler)
+        // to a 256 bit boundary (ymm register alignment)
+        // The cache8 type is deliberately oversized to permit this.
+        ADDQ $31, CX
+        ANDB $-32, CL
+
+#define a Y0
+#define b Y1
+#define c Y2
+#define d Y3
+
+#define sa Y4
+#define sb Y5
+#define sc Y6
+#define sd Y7
+
+#define tmp  Y8
+#define tmp2 Y9
+
+#define mask Y10
+#define off  Y11
+
+#define ones Y12
+
+#define rtmp1  Y13
+#define rtmp2  Y14
+
+#define mem   Y15
+
+#define dig    BX
+#define cache  CX
+#define count  DX
+#define base   SI
+#define consts DI
+
+#define prepmask \
+        VPXOR    mask, mask, mask \
+        VPCMPGTD mask, off, mask
+
+#define prep(index) \
+        VMOVAPD    mask, rtmp2                      \
+        VPGATHERDD rtmp2, index*4(base)(off*1), mem
+
+#define load(index) \
+        VMOVAPD index*32(cache), mem
+
+#define store(index) \
+        VMOVAPD mem, index*32(cache)
+
+#define roll(shift, a) \
+        VPSLLD $shift, a, rtmp1 \
+        VPSRLD $32-shift, a, a  \
+        VPOR   rtmp1, a, a
+
+#define ROUND1(a, b, c, d, index, const, shift) \
+        VPXOR   c, tmp, tmp            \
+        VPADDD  32*const(consts), a, a \
+        VPADDD  mem, a, a              \
+        VPAND   b, tmp, tmp            \
+        VPXOR   d, tmp, tmp            \
+        prep(index)                    \
+        VPADDD  tmp, a, a              \
+        roll(shift,a)                  \
+        VMOVAPD c, tmp                 \
+        VPADDD  b, a, a
+
+#define ROUND1load(a, b, c, d, index, const, shift) \
+        VXORPD  c, tmp, tmp            \
+        VPADDD  32*const(consts), a, a \
+        VPADDD  mem, a, a              \
+        VPAND   b, tmp, tmp            \
+        VPXOR   d, tmp, tmp            \
+        load(index)                    \
+        VPADDD  tmp, a, a              \
+        roll(shift,a)                  \
+        VMOVAPD c, tmp                 \
+        VPADDD  b, a, a
+
+#define ROUND2(a, b, c, d, index, const, shift) \
+        VPADDD  32*const(consts), a, a \
+        VPADDD  mem, a, a              \
+        VPAND   b, tmp2, tmp2          \
+        VANDNPD c, tmp, tmp            \
+        load(index)                    \
+        VPOR    tmp, tmp2, tmp2        \
+        VMOVAPD c, tmp                 \
+        VPADDD  tmp2, a, a             \
+        VMOVAPD c, tmp2                \
+        roll(shift,a)                  \
+        VPADDD  b, a, a
+
+#define ROUND3(a, b, c, d, index, const, shift) \
+        VPADDD  32*const(consts), a, a \
+        VPADDD  mem, a, a              \
+        load(index)                    \
+        VPXOR   d, tmp, tmp            \
+        VPXOR   b, tmp, tmp            \
+        VPADDD  tmp, a, a              \
+        roll(shift,a)                  \
+        VMOVAPD b, tmp                 \
+        VPADDD  b, a, a
+
+#define ROUND4(a, b, c, d, index, const, shift) \
+        VPADDD 32*const(consts), a, a \
+        VPADDD mem, a, a              \
+        VPOR   b, tmp, tmp            \
+        VPXOR  c, tmp, tmp            \
+        VPADDD tmp, a, a              \
+        load(index)                   \
+        roll(shift,a)                 \
+        VPXOR  c, ones, tmp           \
+        VPADDD b, a, a
+
+        // load digest into state registers
+        VMOVUPD (dig), a
+        VMOVUPD 32(dig), b
+        VMOVUPD 64(dig), c
+        VMOVUPD 96(dig), d
+
+        // load source buffer offsets
+        VMOVUPD (AX), off
+
+        prepmask
+        VPCMPEQD ones, ones, ones
+
+loop:
+        VMOVAPD a, sa
+        VMOVAPD b, sb
+        VMOVAPD c, sc
+        VMOVAPD d, sd
+
+        prep(0)
+        VMOVAPD d, tmp
+        store(0)
+
+        ROUND1(a,b,c,d, 1,0x00, 7)
+        store(1)
+        ROUND1(d,a,b,c, 2,0x01,12)
+        store(2)
+        ROUND1(c,d,a,b, 3,0x02,17)
+        store(3)
+        ROUND1(b,c,d,a, 4,0x03,22)
+        store(4)
+        ROUND1(a,b,c,d, 5,0x04, 7)
+        store(5)
+        ROUND1(d,a,b,c, 6,0x05,12)
+        store(6)
+        ROUND1(c,d,a,b, 7,0x06,17)
+        store(7)
+        ROUND1(b,c,d,a, 8,0x07,22)
+        store(8)
+        ROUND1(a,b,c,d, 9,0x08, 7)
+        store(9)
+        ROUND1(d,a,b,c,10,0x09,12)
+        store(10)
+        ROUND1(c,d,a,b,11,0x0a,17)
+        store(11)
+        ROUND1(b,c,d,a,12,0x0b,22)
+        store(12)
+        ROUND1(a,b,c,d,13,0x0c, 7)
+        store(13)
+        ROUND1(d,a,b,c,14,0x0d,12)
+        store(14)
+        ROUND1(c,d,a,b,15,0x0e,17)
+        store(15)
+        ROUND1load(b,c,d,a, 1,0x0f,22)
+
+        VMOVAPD d, tmp
+        VMOVAPD d, tmp2
+
+        ROUND2(a,b,c,d, 6,0x10, 5)
+        ROUND2(d,a,b,c,11,0x11, 9)
+        ROUND2(c,d,a,b, 0,0x12,14)
+        ROUND2(b,c,d,a, 5,0x13,20)
+        ROUND2(a,b,c,d,10,0x14, 5)
+        ROUND2(d,a,b,c,15,0x15, 9)
+        ROUND2(c,d,a,b, 4,0x16,14)
+        ROUND2(b,c,d,a, 9,0x17,20)
+        ROUND2(a,b,c,d,14,0x18, 5)
+        ROUND2(d,a,b,c, 3,0x19, 9)
+        ROUND2(c,d,a,b, 8,0x1a,14)
+        ROUND2(b,c,d,a,13,0x1b,20)
+        ROUND2(a,b,c,d, 2,0x1c, 5)
+        ROUND2(d,a,b,c, 7,0x1d, 9)
+        ROUND2(c,d,a,b,12,0x1e,14)
+        ROUND2(b,c,d,a, 0,0x1f,20)
+
+        load(5)
+        VMOVAPD c, tmp
+
+        ROUND3(a,b,c,d, 8,0x20, 4)
+        ROUND3(d,a,b,c,11,0x21,11)
+        ROUND3(c,d,a,b,14,0x22,16)
+        ROUND3(b,c,d,a, 1,0x23,23)
+        ROUND3(a,b,c,d, 4,0x24, 4)
+        ROUND3(d,a,b,c, 7,0x25,11)
+        ROUND3(c,d,a,b,10,0x26,16)
+        ROUND3(b,c,d,a,13,0x27,23)
+        ROUND3(a,b,c,d, 0,0x28, 4)
+        ROUND3(d,a,b,c, 3,0x29,11)
+        ROUND3(c,d,a,b, 6,0x2a,16)
+        ROUND3(b,c,d,a, 9,0x2b,23)
+        ROUND3(a,b,c,d,12,0x2c, 4)
+        ROUND3(d,a,b,c,15,0x2d,11)
+        ROUND3(c,d,a,b, 2,0x2e,16)
+        ROUND3(b,c,d,a, 0,0x2f,23)
+
+        load(0)
+        VPXOR d, ones, tmp
+
+        ROUND4(a,b,c,d, 7,0x30, 6)
+        ROUND4(d,a,b,c,14,0x31,10)
+        ROUND4(c,d,a,b, 5,0x32,15)
+        ROUND4(b,c,d,a,12,0x33,21)
+        ROUND4(a,b,c,d, 3,0x34, 6)
+        ROUND4(d,a,b,c,10,0x35,10)
+        ROUND4(c,d,a,b, 1,0x36,15)
+        ROUND4(b,c,d,a, 8,0x37,21)
+        ROUND4(a,b,c,d,15,0x38, 6)
+        ROUND4(d,a,b,c, 6,0x39,10)
+        ROUND4(c,d,a,b,13,0x3a,15)
+        ROUND4(b,c,d,a, 4,0x3b,21)
+        ROUND4(a,b,c,d,11,0x3c, 6)
+        ROUND4(d,a,b,c, 2,0x3d,10)
+        ROUND4(c,d,a,b, 9,0x3e,15)
+        ROUND4(b,c,d,a, 0,0x3f,21)
+
+        VPADDD sa, a, a
+        VPADDD sb, b, b
+        VPADDD sc, c, c
+        VPADDD sd, d, d
+
+        LEAQ 64(base), base
+        SUBQ $64, count
+        JNE  loop
+
+        VMOVUPD a, (dig)
+        VMOVUPD b, 32(dig)
+        VMOVUPD c, 64(dig)
+        VMOVUPD d, 96(dig)
+
+        VZEROUPPER
+        RET
diff --git a/vendor/github.com/minio/md5-simd/block_amd64.go b/vendor/github.com/minio/md5-simd/block_amd64.go
new file mode 100644
index 0000000..16edda2
--- /dev/null
+++ b/vendor/github.com/minio/md5-simd/block_amd64.go
@@ -0,0 +1,210 @@
+//+build !noasm,!appengine,gc
+
+// Copyright (c) 2020 MinIO Inc. All rights reserved.
+// Use of this source code is governed by a license that can be
+// found in the LICENSE file.
+
+package md5simd
+
+import (
+        "fmt"
+        "math"
+        "unsafe"
+
+        "github.com/klauspost/cpuid/v2"
+)
+
+var hasAVX512 bool
+
+func init() {
+        // VANDNPD requires AVX512DQ. Technically it could be VPTERNLOGQ which is AVX512F.
+        hasAVX512 = cpuid.CPU.Supports(cpuid.AVX512F, cpuid.AVX512DQ)
+}
+
+//go:noescape
+func block8(state *uint32, base uintptr, bufs *int32, cache *byte, n int)
+
+//go:noescape
+func block16(state *uint32, base uintptr, ptrs *int32, mask uint64, n int)
+
+// 8-way 4x uint32 digests in 4 ymm registers
+// (ymm0, ymm1, ymm2, ymm3)
+type digest8 struct {
+        v0, v1, v2, v3 [8]uint32
+}
+
+// Stack cache for 8x64 byte md5.BlockSize bytes.
+// Must be 32-byte aligned, so allocate 512+32 and
+// align upwards at runtime.
+type cache8 [512 + 32]byte
+
+// MD5 magic numbers for one lane of hashing; inflated
+// 8x below at init time.
+var md5consts = [64]uint32{
+        0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
+        0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
+        0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
+        0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
+        0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
+        0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
+        0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
+        0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
+        0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
+        0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
+        0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
+        0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
+        0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
+        0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
+        0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
+        0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
+}
+
+// inflate the consts 8-way for 8x md5 (256 bit ymm registers)
+var avx256md5consts = func(c []uint32) []uint32 {
+        inf := make([]uint32, 8*len(c))
+        for i := range c {
+                for j := 0; j < 8; j++ {
+                        inf[(i*8)+j] = c[i]
+                }
+        }
+        return inf
+}(md5consts[:])
+
+// 16-way 4x uint32 digests in 4 zmm registers
+type digest16 struct {
+        v0, v1, v2, v3 [16]uint32
+}
+
+// inflate the consts 16-way for 16x md5 (512 bit zmm registers)
+var avx512md5consts = func(c []uint32) []uint32 {
+        inf := make([]uint32, 16*len(c))
+        for i := range c {
+                for j := 0; j < 16; j++ {
+                        inf[(i*16)+j] = c[i]
+                }
+        }
+        return inf
+}(md5consts[:])
+
+// Interface function to assembly code
+func (s *md5Server) blockMd5_x16(d *digest16, input [16][]byte, half bool) {
+        if hasAVX512 {
+                blockMd5_avx512(d, input, s.allBufs, &s.maskRounds16)
+                return
+        }
+
+        // Preparing data using copy is slower since copies aren't inlined.
+
+        // Calculate on this goroutine
+        if half {
+                for i := range s.i8[0][:] {
+                        s.i8[0][i] = input[i]
+                }
+                for i := range s.d8a.v0[:] {
+                        s.d8a.v0[i], s.d8a.v1[i], s.d8a.v2[i], s.d8a.v3[i] = d.v0[i], d.v1[i], d.v2[i], d.v3[i]
+                }
+                blockMd5_avx2(&s.d8a, s.i8[0], s.allBufs, &s.maskRounds8a)
+                for i := range s.d8a.v0[:] {
+                        d.v0[i], d.v1[i], d.v2[i], d.v3[i] = s.d8a.v0[i], s.d8a.v1[i], s.d8a.v2[i], s.d8a.v3[i]
+                }
+                return
+        }
+
+        for i := range s.i8[0][:] {
+                s.i8[0][i], s.i8[1][i] = input[i], input[8+i]
+        }
+
+        for i := range s.d8a.v0[:] {
+                j := (i + 8) & 15
+                s.d8a.v0[i], s.d8a.v1[i], s.d8a.v2[i], s.d8a.v3[i] = d.v0[i], d.v1[i], d.v2[i], d.v3[i]
+                s.d8b.v0[i], s.d8b.v1[i], s.d8b.v2[i], s.d8b.v3[i] = d.v0[j], d.v1[j], d.v2[j], d.v3[j]
+        }
+
+        // Benchmarks appears to be slightly faster when spinning up 2 goroutines instead
+        // of using the current for one of the blocks.
+        s.wg.Add(2)
+        go func() { blockMd5_avx2(&s.d8a, s.i8[0], s.allBufs, &s.maskRounds8a); s.wg.Done() }()
+        go func() { blockMd5_avx2(&s.d8b, s.i8[1], s.allBufs, &s.maskRounds8b); s.wg.Done() }()
+        s.wg.Wait()
+        for i := range s.d8a.v0[:] {
+                d.v0[i], d.v1[i], d.v2[i], d.v3[i] = s.d8a.v0[i], s.d8a.v1[i], s.d8a.v2[i], s.d8a.v3[i]
+        }
+        for i := range s.d8b.v0[:] {
+                j := (i + 8) & 15
+                d.v0[j], d.v1[j], d.v2[j], d.v3[j] = s.d8b.v0[i], s.d8b.v1[i], s.d8b.v2[i], s.d8b.v3[i]
+        }
+}
+
+// Interface function to AVX512 assembly code
+func blockMd5_avx512(s *digest16, input [16][]byte, base []byte, maskRounds *[16]maskRounds) {
+        baseMin := uint64(uintptr(unsafe.Pointer(&(base[0]))))
+        ptrs := [16]int32{}
+
+        for i := range ptrs {
+                if len(input[i]) > 0 {
+                        if len(input[i]) > internalBlockSize {
+                                panic(fmt.Sprintf("Sanity check fails for lane %d: maximum input length cannot exceed internalBlockSize", i))
+                        }
+
+                        off := uint64(uintptr(unsafe.Pointer(&(input[i][0])))) - baseMin
+                        if off > math.MaxUint32 {
+                                panic(fmt.Sprintf("invalid buffer sent with offset %x", off))
+                        }
+                        ptrs[i] = int32(off)
+                }
+        }
+
+        sdup := *s // create copy of initial states to receive intermediate updates
+
+        rounds := generateMaskAndRounds16(input, maskRounds)
+
+        for r := 0; r < rounds; r++ {
+                m := maskRounds[r]
+
+                block16(&sdup.v0[0], uintptr(baseMin), &ptrs[0], m.mask, int(64*m.rounds))
+
+                for j := 0; j < len(ptrs); j++ {
+                        ptrs[j] += int32(64 * m.rounds) // update pointers for next round
+                        if m.mask&(1<<j) != 0 {         // update digest if still masked as active
+                                (*s).v0[j], (*s).v1[j], (*s).v2[j], (*s).v3[j] = sdup.v0[j], sdup.v1[j], sdup.v2[j], sdup.v3[j]
+                        }
+                }
+        }
+}
+
+// Interface function to AVX2 assembly code
+func blockMd5_avx2(s *digest8, input [8][]byte, base []byte, maskRounds *[8]maskRounds) {
+        baseMin := uint64(uintptr(unsafe.Pointer(&(base[0])))) - 4
+        ptrs := [8]int32{}
+
+        for i := range ptrs {
+                if len(input[i]) > 0 {
+                        if len(input[i]) > internalBlockSize {
+                                panic(fmt.Sprintf("Sanity check fails for lane %d: maximum input length cannot exceed internalBlockSize", i))
+                        }
+
+                        off := uint64(uintptr(unsafe.Pointer(&(input[i][0])))) - baseMin
+                        if off > math.MaxUint32 {
+                                panic(fmt.Sprintf("invalid buffer sent with offset %x", off))
+                        }
+                        ptrs[i] = int32(off)
+                }
+        }
+
+        sdup := *s // create copy of initial states to receive intermediate updates
+
+        rounds := generateMaskAndRounds8(input, maskRounds)
+
+        for r := 0; r < rounds; r++ {
+                m := maskRounds[r]
+                var cache cache8 // stack storage for block8 tmp state
+                block8(&sdup.v0[0], uintptr(baseMin), &ptrs[0], &cache[0], int(64*m.rounds))
+
+                for j := 0; j < len(ptrs); j++ {
+                        ptrs[j] += int32(64 * m.rounds) // update pointers for next round
+                        if m.mask&(1<<j) != 0 {         // update digest if still masked as active
+                                (*s).v0[j], (*s).v1[j], (*s).v2[j], (*s).v3[j] = sdup.v0[j], sdup.v1[j], sdup.v2[j], sdup.v3[j]
+                        }
+                }
+        }
+}
diff --git a/vendor/github.com/minio/md5-simd/md5-digest_amd64.go b/vendor/github.com/minio/md5-simd/md5-digest_amd64.go
new file mode 100644
index 0000000..5ea23a4
--- /dev/null
+++ b/vendor/github.com/minio/md5-simd/md5-digest_amd64.go
@@ -0,0 +1,188 @@
+//+build !noasm,!appengine,gc
+
+// Copyright (c) 2020 MinIO Inc. All rights reserved.
+// Use of this source code is governed by a license that can be
+// found in the LICENSE file.
+
+package md5simd
+
+import (
+        "encoding/binary"
+        "errors"
+        "fmt"
+        "sync"
+        "sync/atomic"
+)
+
+// md5Digest - Type for computing MD5 using either AVX2 or AVX512
+type md5Digest struct {
+        uid         uint64
+        blocksCh    chan blockInput
+        cycleServer chan uint64
+        x           [BlockSize]byte
+        nx          int
+        len         uint64
+        buffers     <-chan []byte
+}
+
+// NewHash - initialize instance for Md5 implementation.
+func (s *md5Server) NewHash() Hasher {
+        uid := atomic.AddUint64(&s.uidCounter, 1)
+        blockCh := make(chan blockInput, buffersPerLane)
+        s.newInput <- newClient{
+                uid:   uid,
+                input: blockCh,
+        }
+        return &md5Digest{
+                uid:         uid,
+                buffers:     s.buffers,
+                blocksCh:    blockCh,
+                cycleServer: s.cycle,
+        }
+}
+
+// Size - Return size of checksum
+func (d *md5Digest) Size() int { return Size }
+
+// BlockSize - Return blocksize of checksum
+func (d md5Digest) BlockSize() int { return BlockSize }
+
+func (d *md5Digest) Reset() {
+        if d.blocksCh == nil {
+                panic("reset after close")
+        }
+        d.nx = 0
+        d.len = 0
+        d.sendBlock(blockInput{uid: d.uid, reset: true}, false)
+}
+
+// write to digest
+func (d *md5Digest) Write(p []byte) (nn int, err error) {
+        if d.blocksCh == nil {
+                return 0, errors.New("md5Digest closed")
+        }
+
+        // break input into chunks of maximum internalBlockSize size
+        for {
+                l := len(p)
+                if l > internalBlockSize {
+                        l = internalBlockSize
+                }
+                nnn, err := d.write(p[:l])
+                if err != nil {
+                        return nn, err
+                }
+                nn += nnn
+                p = p[l:]
+
+                if len(p) == 0 {
+                        break
+                }
+
+        }
+        return
+}
+
+func (d *md5Digest) 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 == BlockSize {
+                        // Create a copy of the overflow buffer in order to send it async over the channel
+                        // (since we will modify the overflow buffer down below with any access beyond multiples of 64)
+                        tmp := <-d.buffers
+                        tmp = tmp[:BlockSize]
+                        copy(tmp, d.x[:])
+                        d.sendBlock(blockInput{uid: d.uid, msg: tmp}, len(p)-n < BlockSize)
+                        d.nx = 0
+                }
+                p = p[n:]
+        }
+        if len(p) >= BlockSize {
+                n := len(p) &^ (BlockSize - 1)
+                buf := <-d.buffers
+                buf = buf[:n]
+                copy(buf, p)
+                d.sendBlock(blockInput{uid: d.uid, msg: buf}, len(p)-n < BlockSize)
+                p = p[n:]
+        }
+        if len(p) > 0 {
+                d.nx = copy(d.x[:], p)
+        }
+        return
+}
+
+func (d *md5Digest) Close() {
+        if d.blocksCh != nil {
+                close(d.blocksCh)
+                d.blocksCh = nil
+        }
+}
+
+var sumChPool sync.Pool
+
+func init() {
+        sumChPool.New = func() interface{} {
+                return make(chan sumResult, 1)
+        }
+}
+
+// Sum - Return MD5 sum in bytes
+func (d *md5Digest) Sum(in []byte) (result []byte) {
+        if d.blocksCh == nil {
+                panic("sum after close")
+        }
+
+        trail := <-d.buffers
+        trail = append(trail[:0], d.x[:d.nx]...)
+
+        length := d.len
+        // Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
+        var tmp [64]byte
+        tmp[0] = 0x80
+        if length%64 < 56 {
+                trail = append(trail, tmp[0:56-length%64]...)
+        } else {
+                trail = append(trail, tmp[0:64+56-length%64]...)
+        }
+
+        // Length in bits.
+        length <<= 3
+        binary.LittleEndian.PutUint64(tmp[:], length) // append length in bits
+
+        trail = append(trail, tmp[0:8]...)
+        if len(trail)%BlockSize != 0 {
+                panic(fmt.Errorf("internal error: sum block was not aligned. len=%d, nx=%d", len(trail), d.nx))
+        }
+        sumCh := sumChPool.Get().(chan sumResult)
+        d.sendBlock(blockInput{uid: d.uid, msg: trail, sumCh: sumCh}, true)
+
+        sum := <-sumCh
+        sumChPool.Put(sumCh)
+
+        return append(in, sum.digest[:]...)
+}
+
+// sendBlock will send a block for processing.
+// If cycle is true we will block on cycle, otherwise we will only block
+// if the block channel is full.
+func (d *md5Digest) sendBlock(bi blockInput, cycle bool) {
+        if cycle {
+                select {
+                case d.blocksCh <- bi:
+                        d.cycleServer <- d.uid
+                }
+                return
+        }
+        // Only block on cycle if we filled the buffer
+        select {
+        case d.blocksCh <- bi:
+                return
+        default:
+                d.cycleServer <- d.uid
+                d.blocksCh <- bi
+        }
+}
diff --git a/vendor/github.com/minio/md5-simd/md5-server_amd64.go b/vendor/github.com/minio/md5-simd/md5-server_amd64.go
new file mode 100644
index 0000000..94f741c
--- /dev/null
+++ b/vendor/github.com/minio/md5-simd/md5-server_amd64.go
@@ -0,0 +1,397 @@
+//+build !noasm,!appengine,gc
+
+// Copyright (c) 2020 MinIO Inc. All rights reserved.
+// Use of this source code is governed by a license that can be
+// found in the LICENSE file.
+
+package md5simd
+
+import (
+        "encoding/binary"
+        "fmt"
+        "runtime"
+        "sync"
+
+        "github.com/klauspost/cpuid/v2"
+)
+
+// MD5 initialization constants
+const (
+        // Lanes is the number of concurrently calculated hashes.
+        Lanes = 16
+
+        init0 = 0x67452301
+        init1 = 0xefcdab89
+        init2 = 0x98badcfe
+        init3 = 0x10325476
+
+        // Use scalar routine when below this many lanes
+        useScalarBelow = 3
+)
+
+// md5ServerUID - Does not start at 0 but next multiple of 16 so as to be able to
+// differentiate with default initialisation value of 0
+const md5ServerUID = Lanes
+
+const buffersPerLane = 3
+
+// Message to send across input channel
+type blockInput struct {
+        uid   uint64
+        msg   []byte
+        sumCh chan sumResult
+        reset bool
+}
+
+type sumResult struct {
+        digest [Size]byte
+}
+
+type lanesInfo [Lanes]blockInput
+
+// md5Server - Type to implement parallel handling of MD5 invocations
+type md5Server struct {
+        uidCounter   uint64
+        cycle        chan uint64           // client with uid has update.
+        newInput     chan newClient        // Add new client.
+        digests      map[uint64][Size]byte // Map of uids to (interim) digest results
+        maskRounds16 [16]maskRounds        // Pre-allocated static array for max 16 rounds
+        maskRounds8a [8]maskRounds         // Pre-allocated static array for max 8 rounds (1st AVX2 core)
+        maskRounds8b [8]maskRounds         // Pre-allocated static array for max 8 rounds (2nd AVX2 core)
+        allBufs      []byte                // Preallocated buffer.
+        buffers      chan []byte           // Preallocated buffers, sliced from allBufs.
+
+        i8       [2][8][]byte // avx2 temporary vars
+        d8a, d8b digest8
+        wg       sync.WaitGroup
+}
+
+// NewServer - Create new object for parallel processing handling
+func NewServer() Server {
+        if !cpuid.CPU.Supports(cpuid.AVX2) {
+                return &fallbackServer{}
+        }
+        md5srv := &md5Server{}
+        md5srv.digests = make(map[uint64][Size]byte)
+        md5srv.newInput = make(chan newClient, Lanes)
+        md5srv.cycle = make(chan uint64, Lanes*10)
+        md5srv.uidCounter = md5ServerUID - 1
+        md5srv.allBufs = make([]byte, 32+buffersPerLane*Lanes*internalBlockSize)
+        md5srv.buffers = make(chan []byte, buffersPerLane*Lanes)
+        // Fill buffers.
+        for i := 0; i < buffersPerLane*Lanes; i++ {
+                s := 32 + i*internalBlockSize
+                md5srv.buffers <- md5srv.allBufs[s : s+internalBlockSize : s+internalBlockSize]
+        }
+
+        // Start a single thread for reading from the input channel
+        go md5srv.process(md5srv.newInput)
+        return md5srv
+}
+
+type newClient struct {
+        uid   uint64
+        input chan blockInput
+}
+
+// process - Sole handler for reading from the input channel.
+func (s *md5Server) process(newClients chan newClient) {
+        // To fill up as many lanes as possible:
+        //
+        // 1. Wait for a cycle id.
+        // 2. If not already in a lane, add, otherwise leave on channel
+        // 3. Start timer
+        // 4. Check if lanes is full, if so, goto 10 (process).
+        // 5. If timeout, goto 10.
+        // 6. Wait for new id (goto 2)  or timeout (goto 10).
+        // 10. Process.
+        // 11. Check all input if there is already input, if so add to lanes.
+        // 12. Goto 1
+
+        // lanes contains the lanes.
+        var lanes lanesInfo
+        // lanesFilled contains the number of filled lanes for current cycle.
+        var lanesFilled int
+        // clients contains active clients
+        var clients = make(map[uint64]chan blockInput, Lanes)
+
+        addToLane := func(uid uint64) {
+                cl, ok := clients[uid]
+                if !ok {
+                        // Unknown client. Maybe it was already removed.
+                        return
+                }
+                // Check if we already have it.
+                for _, lane := range lanes[:lanesFilled] {
+                        if lane.uid == uid {
+                                return
+                        }
+                }
+                // Continue until we get a block or there is nothing on channel
+                for {
+                        select {
+                        case block, ok := <-cl:
+                                if !ok {
+                                        // Client disconnected
+                                        delete(clients, block.uid)
+                                        return
+                                }
+                                if block.uid != uid {
+                                        panic(fmt.Errorf("uid mismatch, %d (block) != %d (client)", block.uid, uid))
+                                }
+                                // If reset message, reset and we're done
+                                if block.reset {
+                                        delete(s.digests, uid)
+                                        continue
+                                }
+
+                                // If requesting sum, we will need to maintain state.
+                                if block.sumCh != nil {
+                                        var dig digest
+                                        d, ok := s.digests[uid]
+                                        if ok {
+                                                dig.s[0] = binary.LittleEndian.Uint32(d[0:4])
+                                                dig.s[1] = binary.LittleEndian.Uint32(d[4:8])
+                                                dig.s[2] = binary.LittleEndian.Uint32(d[8:12])
+                                                dig.s[3] = binary.LittleEndian.Uint32(d[12:16])
+                                        } else {
+                                                dig.s[0], dig.s[1], dig.s[2], dig.s[3] = init0, init1, init2, init3
+                                        }
+
+                                        sum := sumResult{}
+                                        // Add end block to current digest.
+                                        blockScalar(&dig.s, block.msg)
+
+                                        binary.LittleEndian.PutUint32(sum.digest[0:], dig.s[0])
+                                        binary.LittleEndian.PutUint32(sum.digest[4:], dig.s[1])
+                                        binary.LittleEndian.PutUint32(sum.digest[8:], dig.s[2])
+                                        binary.LittleEndian.PutUint32(sum.digest[12:], dig.s[3])
+                                        block.sumCh <- sum
+                                        if block.msg != nil {
+                                                s.buffers <- block.msg
+                                        }
+                                        continue
+                                }
+                                if len(block.msg) == 0 {
+                                        continue
+                                }
+                                lanes[lanesFilled] = block
+                                lanesFilled++
+                                return
+                        default:
+                                return
+                        }
+                }
+        }
+        addNewClient := func(cl newClient) {
+                if _, ok := clients[cl.uid]; ok {
+                        panic("internal error: duplicate client registration")
+                }
+                clients[cl.uid] = cl.input
+        }
+
+        allLanesFilled := func() bool {
+                return lanesFilled == Lanes || lanesFilled >= len(clients)
+        }
+
+        for {
+                // Step 1.
+                for lanesFilled == 0 {
+                        select {
+                        case cl, ok := <-newClients:
+                                if !ok {
+                                        return
+                                }
+                                addNewClient(cl)
+                                // Check if it already sent a payload.
+                                addToLane(cl.uid)
+                                continue
+                        case uid := <-s.cycle:
+                                addToLane(uid)
+                        }
+                }
+
+        fillLanes:
+                for !allLanesFilled() {
+                        select {
+                        case cl, ok := <-newClients:
+                                if !ok {
+                                        return
+                                }
+                                addNewClient(cl)
+
+                        case uid := <-s.cycle:
+                                addToLane(uid)
+                        default:
+                                // Nothing more queued...
+                                break fillLanes
+                        }
+                }
+
+                // If we did not fill all lanes, check if there is more waiting
+                if !allLanesFilled() {
+                        runtime.Gosched()
+                        for uid := range clients {
+                                addToLane(uid)
+                                if allLanesFilled() {
+                                        break
+                                }
+                        }
+                }
+                if false {
+                        if !allLanesFilled() {
+                                fmt.Println("Not all lanes filled", lanesFilled, "of", len(clients))
+                                //pprof.Lookup("goroutine").WriteTo(os.Stdout, 1)
+                        } else if true {
+                                fmt.Println("all lanes filled")
+                        }
+                }
+                // Process the lanes we could collect
+                s.blocks(lanes[:lanesFilled])
+
+                // Clear lanes...
+                lanesFilled = 0
+                // Add all current queued
+                for uid := range clients {
+                        addToLane(uid)
+                        if allLanesFilled() {
+                                break
+                        }
+                }
+        }
+}
+
+func (s *md5Server) Close() {
+        if s.newInput != nil {
+                close(s.newInput)
+                s.newInput = nil
+        }
+}
+
+// Invoke assembly and send results back
+func (s *md5Server) blocks(lanes []blockInput) {
+        if len(lanes) < useScalarBelow {
+                // Use scalar routine when below this many lanes
+                switch len(lanes) {
+                case 0:
+                case 1:
+                        lane := lanes[0]
+                        var d digest
+                        a, ok := s.digests[lane.uid]
+                        if ok {
+                                d.s[0] = binary.LittleEndian.Uint32(a[0:4])
+                                d.s[1] = binary.LittleEndian.Uint32(a[4:8])
+                                d.s[2] = binary.LittleEndian.Uint32(a[8:12])
+                                d.s[3] = binary.LittleEndian.Uint32(a[12:16])
+                        } else {
+                                d.s[0] = init0
+                                d.s[1] = init1
+                                d.s[2] = init2
+                                d.s[3] = init3
+                        }
+                        if len(lane.msg) > 0 {
+                                // Update...
+                                blockScalar(&d.s, lane.msg)
+                        }
+                        dig := [Size]byte{}
+                        binary.LittleEndian.PutUint32(dig[0:], d.s[0])
+                        binary.LittleEndian.PutUint32(dig[4:], d.s[1])
+                        binary.LittleEndian.PutUint32(dig[8:], d.s[2])
+                        binary.LittleEndian.PutUint32(dig[12:], d.s[3])
+                        s.digests[lane.uid] = dig
+
+                        if lane.msg != nil {
+                                s.buffers <- lane.msg
+                        }
+                        lanes[0] = blockInput{}
+
+                default:
+                        s.wg.Add(len(lanes))
+                        var results [useScalarBelow]digest
+                        for i := range lanes {
+                                lane := lanes[i]
+                                go func(i int) {
+                                        var d digest
+                                        defer s.wg.Done()
+                                        a, ok := s.digests[lane.uid]
+                                        if ok {
+                                                d.s[0] = binary.LittleEndian.Uint32(a[0:4])
+                                                d.s[1] = binary.LittleEndian.Uint32(a[4:8])
+                                                d.s[2] = binary.LittleEndian.Uint32(a[8:12])
+                                                d.s[3] = binary.LittleEndian.Uint32(a[12:16])
+                                        } else {
+                                                d.s[0] = init0
+                                                d.s[1] = init1
+                                                d.s[2] = init2
+                                                d.s[3] = init3
+                                        }
+                                        if len(lane.msg) == 0 {
+                                                results[i] = d
+                                                return
+                                        }
+                                        // Update...
+                                        blockScalar(&d.s, lane.msg)
+                                        results[i] = d
+                                }(i)
+                        }
+                        s.wg.Wait()
+                        for i, lane := range lanes {
+                                dig := [Size]byte{}
+                                binary.LittleEndian.PutUint32(dig[0:], results[i].s[0])
+                                binary.LittleEndian.PutUint32(dig[4:], results[i].s[1])
+                                binary.LittleEndian.PutUint32(dig[8:], results[i].s[2])
+                                binary.LittleEndian.PutUint32(dig[12:], results[i].s[3])
+                                s.digests[lane.uid] = dig
+
+                                if lane.msg != nil {
+                                        s.buffers <- lane.msg
+                                }
+                                lanes[i] = blockInput{}
+                        }
+                }
+                return
+        }
+
+        inputs := [16][]byte{}
+        for i := range lanes {
+                inputs[i] = lanes[i].msg
+        }
+
+        // Collect active digests...
+        state := s.getDigests(lanes)
+        // Process all lanes...
+        s.blockMd5_x16(&state, inputs, len(lanes) <= 8)
+
+        for i, lane := range lanes {
+                uid := lane.uid
+                dig := [Size]byte{}
+                binary.LittleEndian.PutUint32(dig[0:], state.v0[i])
+                binary.LittleEndian.PutUint32(dig[4:], state.v1[i])
+                binary.LittleEndian.PutUint32(dig[8:], state.v2[i])
+                binary.LittleEndian.PutUint32(dig[12:], state.v3[i])
+
+                s.digests[uid] = dig
+                if lane.msg != nil {
+                        s.buffers <- lane.msg
+                }
+                lanes[i] = blockInput{}
+        }
+}
+
+func (s *md5Server) getDigests(lanes []blockInput) (d digest16) {
+        for i, lane := range lanes {
+                a, ok := s.digests[lane.uid]
+                if ok {
+                        d.v0[i] = binary.LittleEndian.Uint32(a[0:4])
+                        d.v1[i] = binary.LittleEndian.Uint32(a[4:8])
+                        d.v2[i] = binary.LittleEndian.Uint32(a[8:12])
+                        d.v3[i] = binary.LittleEndian.Uint32(a[12:16])
+                } else {
+                        d.v0[i] = init0
+                        d.v1[i] = init1
+                        d.v2[i] = init2
+                        d.v3[i] = init3
+                }
+        }
+        return
+}
diff --git a/vendor/github.com/minio/md5-simd/md5-server_fallback.go b/vendor/github.com/minio/md5-simd/md5-server_fallback.go
new file mode 100644
index 0000000..7814dad
--- /dev/null
+++ b/vendor/github.com/minio/md5-simd/md5-server_fallback.go
@@ -0,0 +1,12 @@
+//+build !amd64 appengine !gc noasm
+
+// Copyright (c) 2020 MinIO Inc. All rights reserved.
+// Use of this source code is governed by a license that can be
+// found in the LICENSE file.
+
+package md5simd
+
+// NewServer - Create new object for parallel processing handling
+func NewServer() *fallbackServer {
+        return &fallbackServer{}
+}
diff --git a/vendor/github.com/minio/md5-simd/md5-util_amd64.go b/vendor/github.com/minio/md5-simd/md5-util_amd64.go
new file mode 100644
index 0000000..73981b0
--- /dev/null
+++ b/vendor/github.com/minio/md5-simd/md5-util_amd64.go
@@ -0,0 +1,85 @@
+//+build !noasm,!appengine,gc
+
+// Copyright (c) 2020 MinIO Inc. All rights reserved.
+// Use of this source code is governed by a license that can be
+// found in the LICENSE file.
+
+package md5simd
+
+// Helper struct for sorting blocks based on length
+type lane struct {
+        len uint
+        pos uint
+}
+
+type digest struct {
+        s [4]uint32
+}
+
+// Helper struct for generating number of rounds in combination with mask for valid lanes
+type maskRounds struct {
+        mask   uint64
+        rounds uint64
+}
+
+func generateMaskAndRounds8(input [8][]byte, mr *[8]maskRounds) (rounds int) {
+        // Sort on blocks length small to large
+        var sorted [8]lane
+        for c, inpt := range input[:] {
+                sorted[c] = lane{uint(len(inpt)), uint(c)}
+                for i := c - 1; i >= 0; i-- {
+                        // swap so largest is at the end...
+                        if sorted[i].len > sorted[i+1].len {
+                                sorted[i], sorted[i+1] = sorted[i+1], sorted[i]
+                                continue
+                        }
+                        break
+                }
+        }
+
+        // Create mask array including 'rounds' (of processing blocks of 64 bytes) between masks
+        m, round := uint64(0xff), uint64(0)
+
+        for _, s := range sorted[:] {
+                if s.len > 0 {
+                        if uint64(s.len)>>6 > round {
+                                mr[rounds] = maskRounds{m, (uint64(s.len) >> 6) - round}
+                                rounds++
+                        }
+                        round = uint64(s.len) >> 6
+                }
+                m = m & ^(1 << uint(s.pos))
+        }
+        return
+}
+
+func generateMaskAndRounds16(input [16][]byte, mr *[16]maskRounds) (rounds int) {
+        // Sort on blocks length small to large
+        var sorted [16]lane
+        for c, inpt := range input[:] {
+                sorted[c] = lane{uint(len(inpt)), uint(c)}
+                for i := c - 1; i >= 0; i-- {
+                        // swap so largest is at the end...
+                        if sorted[i].len > sorted[i+1].len {
+                                sorted[i], sorted[i+1] = sorted[i+1], sorted[i]
+                                continue
+                        }
+                        break
+                }
+        }
+
+        // Create mask array including 'rounds' (of processing blocks of 64 bytes) between masks
+        m, round := uint64(0xffff), uint64(0)
+
+        for _, s := range sorted[:] {
+                if s.len > 0 {
+                        if uint64(s.len)>>6 > round {
+                                mr[rounds] = maskRounds{m, (uint64(s.len) >> 6) - round}
+                                rounds++
+                        }
+                        round = uint64(s.len) >> 6
+                }
+                m = m & ^(1 << uint(s.pos))
+        }
+        return
+}
diff --git a/vendor/github.com/minio/md5-simd/md5.go b/vendor/github.com/minio/md5-simd/md5.go
new file mode 100644
index 0000000..11b0cb9
--- /dev/null
+++ b/vendor/github.com/minio/md5-simd/md5.go
@@ -0,0 +1,63 @@
+package md5simd
+
+import (
+        "crypto/md5"
+        "hash"
+        "sync"
+)
+
+const (
+        // The blocksize of MD5 in bytes.
+        BlockSize = 64
+
+        // The size of an MD5 checksum in bytes.
+        Size = 16
+
+        // internalBlockSize is the internal block size.
+        internalBlockSize = 32 << 10
+)
+
+type Server interface {
+        NewHash() Hasher
+        Close()
+}
+
+type Hasher interface {
+        hash.Hash
+        Close()
+}
+
+// StdlibHasher returns a Hasher that uses the stdlib for hashing.
+// Used hashers are stored in a pool for fast reuse.
+func StdlibHasher() Hasher {
+        return &md5Wrapper{Hash: md5Pool.New().(hash.Hash)}
+}
+
+// md5Wrapper is a wrapper around the builtin hasher.
+type md5Wrapper struct {
+        hash.Hash
+}
+
+var md5Pool = sync.Pool{New: func() interface{} {
+        return md5.New()
+}}
+
+// fallbackServer - Fallback when no assembly is available.
+type fallbackServer struct {
+}
+
+// NewHash -- return regular Golang md5 hashing from crypto
+func (s *fallbackServer) NewHash() Hasher {
+        return &md5Wrapper{Hash: md5Pool.New().(hash.Hash)}
+}
+
+func (s *fallbackServer) Close() {
+}
+
+func (m *md5Wrapper) Close() {
+        if m.Hash != nil {
+                m.Reset()
+                md5Pool.Put(m.Hash)
+                m.Hash = nil
+        }
+}
diff --git a/vendor/github.com/minio/md5-simd/md5block_amd64.go b/vendor/github.com/minio/md5-simd/md5block_amd64.go
new file mode 100644
index 0000000..4c27936
--- /dev/null
+++ b/vendor/github.com/minio/md5-simd/md5block_amd64.go
@@ -0,0 +1,11 @@
+// Code generated by command: go run gen.go -out ../md5block_amd64.s -stubs ../md5block_amd64.go -pkg=md5simd. DO NOT EDIT.
+
+// +build !appengine
+// +build !noasm
+// +build gc
+
+package md5simd
+
+// Encode p to digest
+//go:noescape
+func blockScalar(dig *[4]uint32, p []byte)
diff --git a/vendor/github.com/minio/md5-simd/md5block_amd64.s b/vendor/github.com/minio/md5-simd/md5block_amd64.s
new file mode 100644
index 0000000..fbc4a21
--- /dev/null
+++ b/vendor/github.com/minio/md5-simd/md5block_amd64.s
@@ -0,0 +1,714 @@
+// Code generated by command: go run gen.go -out ../md5block_amd64.s -stubs ../md5block_amd64.go -pkg=md5simd. DO NOT EDIT.
+
+// +build !appengine
+// +build !noasm
+// +build gc
+
+// func blockScalar(dig *[4]uint32, p []byte)
+TEXT ·blockScalar(SB), $0-32
+        MOVQ p_len+16(FP), AX
+        MOVQ dig+0(FP), CX
+        MOVQ p_base+8(FP), DX
+        SHRQ $0x06, AX
+        SHLQ $0x06, AX
+        LEAQ (DX)(AX*1), AX
+        CMPQ DX, AX
+        JEQ  end
+        MOVL (CX), BX
+        MOVL 4(CX), BP
+        MOVL 8(CX), SI
+        MOVL 12(CX), CX
+        MOVL $0xffffffff, DI
+
+loop:
+        MOVL (DX), R8
+        MOVL CX, R9
+        MOVL BX, R10
+        MOVL BP, R11
+        MOVL SI, R12
+        MOVL CX, R13
+
+        // ROUND1
+        XORL SI, R9
+        ADDL $0xd76aa478, BX
+        ADDL R8, BX
+        ANDL BP, R9
+        XORL CX, R9
+        MOVL 4(DX), R8
+        ADDL R9, BX
+        ROLL $0x07, BX
+        MOVL SI, R9
+        ADDL BP, BX
+        XORL BP, R9
+        ADDL $0xe8c7b756, CX
+        ADDL R8, CX
+        ANDL BX, R9
+        XORL SI, R9
+        MOVL 8(DX), R8
+        ADDL R9, CX
+        ROLL $0x0c, CX
+        MOVL BP, R9
+        ADDL BX, CX
+        XORL BX, R9
+        ADDL $0x242070db, SI
+        ADDL R8, SI
+        ANDL CX, R9
+        XORL BP, R9
+        MOVL 12(DX), R8
+        ADDL R9, SI
+        ROLL $0x11, SI
+        MOVL BX, R9
+        ADDL CX, SI
+        XORL CX, R9
+        ADDL $0xc1bdceee, BP
+        ADDL R8, BP
+        ANDL SI, R9
+        XORL BX, R9
+        MOVL 16(DX), R8
+        ADDL R9, BP
+        ROLL $0x16, BP
+        MOVL CX, R9
+        ADDL SI, BP
+        XORL SI, R9
+        ADDL $0xf57c0faf, BX
+        ADDL R8, BX
+        ANDL BP, R9
+        XORL CX, R9
+        MOVL 20(DX), R8
+        ADDL R9, BX
+        ROLL $0x07, BX
+        MOVL SI, R9
+        ADDL BP, BX
+        XORL BP, R9
+        ADDL $0x4787c62a, CX
+        ADDL R8, CX
+        ANDL BX, R9
+        XORL SI, R9
+        MOVL 24(DX), R8
+        ADDL R9, CX
+        ROLL $0x0c, CX
+        MOVL BP, R9
+        ADDL BX, CX
+        XORL BX, R9
+        ADDL $0xa8304613, SI
+        ADDL R8, SI
+        ANDL CX, R9
+        XORL BP, R9
+        MOVL 28(DX), R8
+        ADDL R9, SI
+        ROLL $0x11, SI
+        MOVL BX, R9
+        ADDL CX, SI
+        XORL CX, R9
+        ADDL $0xfd469501, BP
+        ADDL R8, BP
+        ANDL SI, R9
+        XORL BX, R9
+        MOVL 32(DX), R8
+        ADDL R9, BP
+        ROLL $0x16, BP
+        MOVL CX, R9
+        ADDL SI, BP
+        XORL SI, R9
+        ADDL $0x698098d8, BX
+        ADDL R8, BX
+        ANDL BP, R9
+        XORL CX, R9
+        MOVL 36(DX), R8
+        ADDL R9, BX
+        ROLL $0x07, BX
+        MOVL SI, R9
+        ADDL BP, BX
+        XORL BP, R9
+        ADDL $0x8b44f7af, CX
+        ADDL R8, CX
+        ANDL BX, R9
+        XORL SI, R9
+        MOVL 40(DX), R8
+        ADDL R9, CX
+        ROLL $0x0c, CX
+        MOVL BP, R9
+        ADDL BX, CX
+        XORL BX, R9
+        ADDL $0xffff5bb1, SI
+        ADDL R8, SI
+        ANDL CX, R9
+        XORL BP, R9
+        MOVL 44(DX), R8
+        ADDL R9, SI
+        ROLL $0x11, SI
+        MOVL BX, R9
+        ADDL CX, SI
+        XORL CX, R9
+        ADDL $0x895cd7be, BP
+        ADDL R8, BP
+        ANDL SI, R9
+        XORL BX, R9
+        MOVL 48(DX), R8
+        ADDL R9, BP
+        ROLL $0x16, BP
+        MOVL CX, R9
+        ADDL SI, BP
+        XORL SI, R9
+        ADDL $0x6b901122, BX
+        ADDL R8, BX
+        ANDL BP, R9
+        XORL CX, R9
+        MOVL 52(DX), R8
+        ADDL R9, BX
+        ROLL $0x07, BX
+        MOVL SI, R9
+        ADDL BP, BX
+        XORL BP, R9
+        ADDL $0xfd987193, CX
+        ADDL R8, CX
+        ANDL BX, R9
+        XORL SI, R9
+        MOVL 56(DX), R8
+        ADDL R9, CX
+        ROLL $0x0c, CX
+        MOVL BP, R9
+        ADDL BX, CX
+        XORL BX, R9
+        ADDL $0xa679438e, SI
+        ADDL R8, SI
+        ANDL CX, R9
+        XORL BP, R9
+        MOVL 60(DX), R8
+        ADDL R9, SI
+        ROLL $0x11, SI
+        MOVL BX, R9
+        ADDL CX, SI
+        XORL CX, R9
+        ADDL $0x49b40821, BP
+        ADDL R8, BP
+        ANDL SI, R9
+        XORL BX, R9
+        MOVL 4(DX), R8
+        ADDL R9, BP
+        ROLL $0x16, BP
+        MOVL CX, R9
+        ADDL SI, BP
+
+        // ROUND2
+        MOVL CX, R9
+        MOVL CX, R14
+        XORL DI, R9
+        ADDL $0xf61e2562, BX
+        ADDL R8, BX
+        ANDL BP, R14
+        ANDL SI, R9
+        MOVL 24(DX), R8
+        ORL  R9, R14
+        MOVL SI, R9
+        ADDL R14, BX
+        MOVL SI, R14
+        ROLL $0x05, BX
+        ADDL BP, BX
+        XORL DI, R9
+        ADDL $0xc040b340, CX
+        ADDL R8, CX
+        ANDL BX, R14
+        ANDL BP, R9
+        MOVL 44(DX), R8
+        ORL  R9, R14
+        MOVL BP, R9
+        ADDL R14, CX
+        MOVL BP, R14
+        ROLL $0x09, CX
+        ADDL BX, CX
+        XORL DI, R9
+        ADDL $0x265e5a51, SI
+        ADDL R8, SI
+        ANDL CX, R14
+        ANDL BX, R9
+        MOVL (DX), R8
+        ORL  R9, R14
+        MOVL BX, R9
+        ADDL R14, SI
+        MOVL BX, R14
+        ROLL $0x0e, SI
+        ADDL CX, SI
+        XORL DI, R9
+        ADDL $0xe9b6c7aa, BP
+        ADDL R8, BP
+        ANDL SI, R14
+        ANDL CX, R9
+        MOVL 20(DX), R8
+        ORL  R9, R14
+        MOVL CX, R9
+        ADDL R14, BP
+        MOVL CX, R14
+        ROLL $0x14, BP
+        ADDL SI, BP
+        XORL DI, R9
+        ADDL $0xd62f105d, BX
+        ADDL R8, BX
+        ANDL BP, R14
+        ANDL SI, R9
+        MOVL 40(DX), R8
+        ORL  R9, R14
+        MOVL SI, R9
+        ADDL R14, BX
+        MOVL SI, R14
+        ROLL $0x05, BX
+        ADDL BP, BX
+        XORL DI, R9
+        ADDL $0x02441453, CX
+        ADDL R8, CX
+        ANDL BX, R14
+        ANDL BP, R9
+        MOVL 60(DX), R8
+        ORL  R9, R14
+        MOVL BP, R9
+        ADDL R14, CX
+        MOVL BP, R14
+        ROLL $0x09, CX
+        ADDL BX, CX
+        XORL DI, R9
+        ADDL $0xd8a1e681, SI
+        ADDL R8, SI
+        ANDL CX, R14
+        ANDL BX, R9
+        MOVL 16(DX), R8
+        ORL  R9, R14
+        MOVL BX, R9
+        ADDL R14, SI
+        MOVL BX, R14
+        ROLL $0x0e, SI
+        ADDL CX, SI
+        XORL DI, R9
+        ADDL $0xe7d3fbc8, BP
+        ADDL R8, BP
+        ANDL SI, R14
+        ANDL CX, R9
+        MOVL 36(DX), R8
+        ORL  R9, R14
+        MOVL CX, R9
+        ADDL R14, BP
+        MOVL CX, R14
+        ROLL $0x14, BP
+        ADDL SI, BP
+        XORL DI, R9
+        ADDL $0x21e1cde6, BX
+        ADDL R8, BX
+        ANDL BP, R14
+        ANDL SI, R9
+        MOVL 56(DX), R8
+        ORL  R9, R14
+        MOVL SI, R9
+        ADDL R14, BX
+        MOVL SI, R14
+        ROLL $0x05, BX
+        ADDL BP, BX
+        XORL DI, R9
+        ADDL $0xc33707d6, CX
+        ADDL R8, CX
+        ANDL BX, R14
+        ANDL BP, R9
+        MOVL 12(DX), R8
+        ORL  R9, R14
+        MOVL BP, R9
+        ADDL R14, CX
+        MOVL BP, R14
+        ROLL $0x09, CX
+        ADDL BX, CX
+        XORL DI, R9
+        ADDL $0xf4d50d87, SI
+        ADDL R8, SI
+        ANDL CX, R14
+        ANDL BX, R9
+        MOVL 32(DX), R8
+        ORL  R9, R14
+        MOVL BX, R9
+        ADDL R14, SI
+        MOVL BX, R14
+        ROLL $0x0e, SI
+        ADDL CX, SI
+        XORL DI, R9
+        ADDL $0x455a14ed, BP
+        ADDL R8, BP
+        ANDL SI, R14
+        ANDL CX, R9
+        MOVL 52(DX), R8
+        ORL  R9, R14
+        MOVL CX, R9
+        ADDL R14, BP
+        MOVL CX, R14
+        ROLL $0x14, BP
+        ADDL SI, BP
+        XORL DI, R9
+        ADDL $0xa9e3e905, BX
+        ADDL R8, BX
+        ANDL BP, R14
+        ANDL SI, R9
+        MOVL 8(DX), R8
+        ORL  R9, R14
+        MOVL SI, R9
+        ADDL R14, BX
+        MOVL SI, R14
+        ROLL $0x05, BX
+        ADDL BP, BX
+        XORL DI, R9
+        ADDL $0xfcefa3f8, CX
+        ADDL R8, CX
+        ANDL BX, R14
+        ANDL BP, R9
+        MOVL 28(DX), R8
+        ORL  R9, R14
+        MOVL BP, R9
+        ADDL R14, CX
+        MOVL BP, R14
+        ROLL $0x09, CX
+        ADDL BX, CX
+        XORL DI, R9
+        ADDL $0x676f02d9, SI
+        ADDL R8, SI
+        ANDL CX, R14
+        ANDL BX, R9
+        MOVL 48(DX), R8
+        ORL  R9, R14
+        MOVL BX, R9
+        ADDL R14, SI
+        MOVL BX, R14
+        ROLL $0x0e, SI
+        ADDL CX, SI
+        XORL DI, R9
+        ADDL $0x8d2a4c8a, BP
+        ADDL R8, BP
+        ANDL SI, R14
+        ANDL CX, R9
+        MOVL 20(DX), R8
+        ORL  R9, R14
+        MOVL CX, R9
+        ADDL R14, BP
+        MOVL CX, R14
+        ROLL $0x14, BP
+        ADDL SI, BP
+
+        // ROUND3
+        MOVL SI, R9
+        ADDL $0xfffa3942, BX
+        ADDL R8, BX
+        MOVL 32(DX), R8
+        XORL CX, R9
+        XORL BP, R9
+        ADDL R9, BX
+        ROLL $0x04, BX
+        MOVL BP, R9
+        ADDL BP, BX
+        ADDL $0x8771f681, CX
+        ADDL R8, CX
+        MOVL 44(DX), R8
+        XORL SI, R9
+        XORL BX, R9
+        ADDL R9, CX
+        ROLL $0x0b, CX
+        MOVL BX, R9
+        ADDL BX, CX
+        ADDL $0x6d9d6122, SI
+        ADDL R8, SI
+        MOVL 56(DX), R8
+        XORL BP, R9
+        XORL CX, R9
+        ADDL R9, SI
+        ROLL $0x10, SI
+        MOVL CX, R9
+        ADDL CX, SI
+        ADDL $0xfde5380c, BP
+        ADDL R8, BP
+        MOVL 4(DX), R8
+        XORL BX, R9
+        XORL SI, R9
+        ADDL R9, BP
+        ROLL $0x17, BP
+        MOVL SI, R9
+        ADDL SI, BP
+        ADDL $0xa4beea44, BX
+        ADDL R8, BX
+        MOVL 16(DX), R8
+        XORL CX, R9
+        XORL BP, R9
+        ADDL R9, BX
+        ROLL $0x04, BX
+        MOVL BP, R9
+        ADDL BP, BX
+        ADDL $0x4bdecfa9, CX
+        ADDL R8, CX
+        MOVL 28(DX), R8
+        XORL SI, R9
+        XORL BX, R9
+        ADDL R9, CX
+        ROLL $0x0b, CX
+        MOVL BX, R9
+        ADDL BX, CX
+        ADDL $0xf6bb4b60, SI
+        ADDL R8, SI
+        MOVL 40(DX), R8
+        XORL BP, R9
+        XORL CX, R9
+        ADDL R9, SI
+        ROLL $0x10, SI
+        MOVL CX, R9
+        ADDL CX, SI
+        ADDL $0xbebfbc70, BP
+        ADDL R8, BP
+        MOVL 52(DX), R8
+        XORL BX, R9
+        XORL SI, R9
+        ADDL R9, BP
+        ROLL $0x17, BP
+        MOVL SI, R9
+        ADDL SI, BP
+        ADDL $0x289b7ec6, BX
+        ADDL R8, BX
+        MOVL (DX), R8
+        XORL CX, R9
+        XORL BP, R9
+        ADDL R9, BX
+        ROLL $0x04, BX
+        MOVL BP, R9
+        ADDL BP, BX
+        ADDL $0xeaa127fa, CX
+        ADDL R8, CX
+        MOVL 12(DX), R8
+        XORL SI, R9
+        XORL BX, R9
+        ADDL R9, CX
+        ROLL $0x0b, CX
+        MOVL BX, R9
+        ADDL BX, CX
+        ADDL $0xd4ef3085, SI
+        ADDL R8, SI
+        MOVL 24(DX), R8
+        XORL BP, R9
+        XORL CX, R9
+        ADDL R9, SI
+        ROLL $0x10, SI
+        MOVL CX, R9
+        ADDL CX, SI
+        ADDL $0x04881d05, BP
+        ADDL R8, BP
+        MOVL 36(DX), R8
+        XORL BX, R9
+        XORL SI, R9
+        ADDL R9, BP
+        ROLL $0x17, BP
+        MOVL SI, R9
+        ADDL SI, BP
+        ADDL $0xd9d4d039, BX
+        ADDL R8, BX
+        MOVL 48(DX), R8
+        XORL CX, R9
+        XORL BP, R9
+        ADDL R9, BX
+        ROLL $0x04, BX
+        MOVL BP, R9
+        ADDL BP, BX
+        ADDL $0xe6db99e5, CX
+        ADDL R8, CX
+        MOVL 60(DX), R8
+        XORL SI, R9
+        XORL BX, R9
+        ADDL R9, CX
+        ROLL $0x0b, CX
+        MOVL BX, R9
+        ADDL BX, CX
+        ADDL $0x1fa27cf8, SI
+        ADDL R8, SI
+        MOVL 8(DX), R8
+        XORL BP, R9
+        XORL CX, R9
+        ADDL R9, SI
+        ROLL $0x10, SI
+        MOVL CX, R9
+        ADDL CX, SI
+        ADDL $0xc4ac5665, BP
+        ADDL R8, BP
+        MOVL (DX), R8
+        XORL BX, R9
+        XORL SI, R9
+        ADDL R9, BP
+        ROLL $0x17, BP
+        MOVL SI, R9
+        ADDL SI, BP
+
+        // ROUND4
+        MOVL DI, R9
+        XORL CX, R9
+        ADDL $0xf4292244, BX
+        ADDL R8, BX
+        ORL  BP, R9
+        XORL SI, R9
+        ADDL R9, BX
+        MOVL 28(DX), R8
+        MOVL DI, R9
+        ROLL $0x06, BX
+        XORL SI, R9
+        ADDL BP, BX
+        ADDL $0x432aff97, CX
+        ADDL R8, CX
+        ORL  BX, R9
+        XORL BP, R9
+        ADDL R9, CX
+        MOVL 56(DX), R8
+        MOVL DI, R9
+        ROLL $0x0a, CX
+        XORL BP, R9
+        ADDL BX, CX
+        ADDL $0xab9423a7, SI
+        ADDL R8, SI
+        ORL  CX, R9
+        XORL BX, R9
+        ADDL R9, SI
+        MOVL 20(DX), R8
+        MOVL DI, R9
+        ROLL $0x0f, SI
+        XORL BX, R9
+        ADDL CX, SI
+        ADDL $0xfc93a039, BP
+        ADDL R8, BP
+        ORL  SI, R9
+        XORL CX, R9
+        ADDL R9, BP
+        MOVL 48(DX), R8
+        MOVL DI, R9
+        ROLL $0x15, BP
+        XORL CX, R9
+        ADDL SI, BP
+        ADDL $0x655b59c3, BX
+        ADDL R8, BX
+        ORL  BP, R9
+        XORL SI, R9
+        ADDL R9, BX
+        MOVL 12(DX), R8
+        MOVL DI, R9
+        ROLL $0x06, BX
+        XORL SI, R9
+        ADDL BP, BX
+        ADDL $0x8f0ccc92, CX
+        ADDL R8, CX
+        ORL  BX, R9
+        XORL BP, R9
+        ADDL R9, CX
+        MOVL 40(DX), R8
+        MOVL DI, R9
+        ROLL $0x0a, CX
+        XORL BP, R9
+        ADDL BX, CX
+        ADDL $0xffeff47d, SI
+        ADDL R8, SI
+        ORL  CX, R9
+        XORL BX, R9
+        ADDL R9, SI
+        MOVL 4(DX), R8
+        MOVL DI, R9
+        ROLL $0x0f, SI
+        XORL BX, R9
+        ADDL CX, SI
+        ADDL $0x85845dd1, BP
+        ADDL R8, BP
+        ORL  SI, R9
+        XORL CX, R9
+        ADDL R9, BP
+        MOVL 32(DX), R8
+        MOVL DI, R9
+        ROLL $0x15, BP
+        XORL CX, R9
+        ADDL SI, BP
+        ADDL $0x6fa87e4f, BX
+        ADDL R8, BX
+        ORL  BP, R9
+        XORL SI, R9
+        ADDL R9, BX
+        MOVL 60(DX), R8
+        MOVL DI, R9
+        ROLL $0x06, BX
+        XORL SI, R9
+        ADDL BP, BX
+        ADDL $0xfe2ce6e0, CX
+        ADDL R8, CX
+        ORL  BX, R9
+        XORL BP, R9
+        ADDL R9, CX
+        MOVL 24(DX), R8
+        MOVL DI, R9
+        ROLL $0x0a, CX
+        XORL BP, R9
+        ADDL BX, CX
+        ADDL $0xa3014314, SI
+        ADDL R8, SI
+        ORL  CX, R9
+        XORL BX, R9
+        ADDL R9, SI
+        MOVL 52(DX), R8
+        MOVL DI, R9
+        ROLL $0x0f, SI
+        XORL BX, R9
+        ADDL CX, SI
+        ADDL $0x4e0811a1, BP
+        ADDL R8, BP
+        ORL  SI, R9
+        XORL CX, R9
+        ADDL R9, BP
+        MOVL 16(DX), R8
+        MOVL DI, R9
+        ROLL $0x15, BP
+        XORL CX, R9
+        ADDL SI, BP
+        ADDL $0xf7537e82, BX
+        ADDL R8, BX
+        ORL  BP, R9
+        XORL SI, R9
+        ADDL R9, BX
+        MOVL 44(DX), R8
+        MOVL DI, R9
+        ROLL $0x06, BX
+        XORL SI, R9
+        ADDL BP, BX
+        ADDL $0xbd3af235, CX
+        ADDL R8, CX
+        ORL  BX, R9
+        XORL BP, R9
+        ADDL R9, CX
+        MOVL 8(DX), R8
+        MOVL DI, R9
+        ROLL $0x0a, CX
+        XORL BP, R9
+        ADDL BX, CX
+        ADDL $0x2ad7d2bb, SI
+        ADDL R8, SI
+        ORL  CX, R9
+        XORL BX, R9
+        ADDL R9, SI
+        MOVL 36(DX), R8
+        MOVL DI, R9
+        ROLL $0x0f, SI
+        XORL BX, R9
+        ADDL CX, SI
+        ADDL $0xeb86d391, BP
+        ADDL R8, BP
+        ORL  SI, R9
+        XORL CX, R9
+        ADDL R9, BP
+        ROLL $0x15, BP
+        ADDL SI, BP
+        ADDL R10, BX
+        ADDL R11, BP
+        ADDL R12, SI
+        ADDL R13, CX
+
+        // Prepare next loop
+        ADDQ $0x40, DX
+        CMPQ DX, AX
+        JB   loop
+
+        // Write output
+        MOVQ dig+0(FP), AX
+        MOVL BX, (AX)
+        MOVL BP, 4(AX)
+        MOVL SI, 8(AX)
+        MOVL CX, 12(AX)
+
+end:
+        RET
diff --git a/vendor/github.com/minio/minio-go/v7/.gitignore b/vendor/github.com/minio/minio-go/v7/.gitignore
new file mode 100644
index 0000000..8ae0384
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/.gitignore
@@ -0,0 +1,6 @@
+*~
+*.test
+validator
+golangci-lint
+functional_tests
+.idea
\ No newline at end of file
diff --git a/vendor/github.com/minio/minio-go/v7/.golangci.yml b/vendor/github.com/minio/minio-go/v7/.golangci.yml
new file mode 100644
index 0000000..875b949
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/.golangci.yml
@@ -0,0 +1,27 @@
+linters-settings:
+  misspell:
+    locale: US
+
+linters:
+  disable-all: true
+  enable:
+    - typecheck
+    - goimports
+    - misspell
+    - revive
+    - govet
+    - ineffassign
+    - gosimple
+    - unused
+    - gocritic
+
+issues:
+  exclude-use-default: false
+  exclude:
+      # todo fix these when we get enough time.
+      - "singleCaseSwitch: should rewrite switch statement to if statement"
+      - "unlambda: replace"
+      - "captLocal:"
+      - "ifElseChain:"
+      - "elseif:"
+      - "should have a package comment"
diff --git a/vendor/github.com/minio/minio-go/v7/CNAME b/vendor/github.com/minio/minio-go/v7/CNAME
new file mode 100644
index 0000000..d365a7b
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/CNAME
@@ -0,0 +1 @@
+minio-go.min.io
\ No newline at end of file
diff --git a/vendor/github.com/minio/minio-go/v7/CONTRIBUTING.md b/vendor/github.com/minio/minio-go/v7/CONTRIBUTING.md
new file mode 100644
index 0000000..24522ef
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/CONTRIBUTING.md
@@ -0,0 +1,22 @@
+###  Developer Guidelines
+
+``minio-go`` welcomes your contribution. To make the process as seamless as possible, we ask for the following:
+
+* Go ahead and fork the project and make your changes. We encourage pull requests to discuss code changes.
+    - Fork it
+    - Create your feature branch (git checkout -b my-new-feature)
+    - Commit your changes (git commit -am 'Add some feature')
+    - Push to the branch (git push origin my-new-feature)
+    - Create new Pull Request
+
+* When you're ready to create a pull request, be sure to:
+    - Have test cases for the new code. If you have questions about how to do it, please ask in your pull request.
+    - Run `go fmt`
+    - Squash your commits into a single commit. `git rebase -i`. It's okay to force update your pull request.
+    - Make sure `go test -race ./...` and `go build` completes.
+      NOTE: go test runs functional tests and requires you to have a AWS S3 account. Set them as environment variables
+      ``ACCESS_KEY`` and ``SECRET_KEY``. To run shorter version of the tests please use ``go test -short -race ./...``
+
+* Read [Effective Go](https://github.com/golang/go/wiki/CodeReviewComments) article from Golang project
+    - `minio-go` project is strictly conformant with Golang style
+    - if you happen to observe offending code, please feel free to send a pull request
diff --git a/vendor/github.com/minio/minio-go/v7/LICENSE b/vendor/github.com/minio/minio-go/v7/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/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.
diff --git a/vendor/github.com/minio/minio-go/v7/MAINTAINERS.md b/vendor/github.com/minio/minio-go/v7/MAINTAINERS.md
new file mode 100644
index 0000000..f640dfb
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/MAINTAINERS.md
@@ -0,0 +1,35 @@
+# For maintainers only
+
+## Responsibilities
+
+Please go through this link [Maintainer Responsibility](https://gist.github.com/abperiasamy/f4d9b31d3186bbd26522)
+
+### Making new releases
+Tag and sign your release commit, additionally this step requires you to have access to MinIO's trusted private key.
+```sh
+$ export GNUPGHOME=/media/${USER}/minio/trusted
+$ git tag -s 4.0.0
+$ git push
+$ git push --tags
+```
+
+### Update version
+Once release has been made update `libraryVersion` constant in `api.go` to next to be released version.
+
+```sh
+$ grep libraryVersion api.go
+      libraryVersion = "4.0.1"
+```
+
+Commit your changes
+```
+$ git commit -a -m "Update version for next release" --author "MinIO Trusted <[email protected]>"
+```
+
+### Announce
+Announce new release by adding release notes at https://github.com/minio/minio-go/releases from `[email protected]` account. Release notes requires two sections `highlights` and `changelog`. Highlights is a bulleted list of salient features in this release and Changelog contains list of all commits since the last release.
+
+To generate `changelog`
+```sh
+$ git log --no-color --pretty=format:'-%d %s (%cr) <%an>' <last_release_tag>..<latest_release_tag>
+```
diff --git a/vendor/github.com/minio/minio-go/v7/Makefile b/vendor/github.com/minio/minio-go/v7/Makefile
new file mode 100644
index 0000000..68444aa
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/Makefile
@@ -0,0 +1,38 @@
+GOPATH := $(shell go env GOPATH)
+TMPDIR := $(shell mktemp -d)
+
+all: checks
+
+.PHONY: examples docs
+
+checks: lint vet test examples functional-test
+
+lint:
+        @mkdir -p ${GOPATH}/bin
+        @echo "Installing golangci-lint" && curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(GOPATH)/bin
+        @echo "Running $@ check"
+        @GO111MODULE=on ${GOPATH}/bin/golangci-lint cache clean
+        @GO111MODULE=on ${GOPATH}/bin/golangci-lint run --timeout=5m --config ./.golangci.yml
+
+vet:
+        @GO111MODULE=on go vet ./...
+        @echo "Installing staticcheck" && go install honnef.co/go/tools/cmd/staticcheck@latest
+        ${GOPATH}/bin/staticcheck -tests=false -checks="all,-ST1000,-ST1003,-ST1016,-ST1020,-ST1021,-ST1022,-ST1023,-ST1005"
+
+test:
+        @GO111MODULE=on SERVER_ENDPOINT=localhost:9000 ACCESS_KEY=minioadmin SECRET_KEY=minioadmin ENABLE_HTTPS=1 MINT_MODE=full go test -race -v ./...
+
+examples:
+        @echo "Building s3 examples"
+        @cd ./examples/s3 && $(foreach v,$(wildcard examples/s3/*.go),go build -mod=mod -o ${TMPDIR}/$(basename $(v)) $(notdir $(v)) || exit 1;)
+        @echo "Building minio examples"
+        @cd ./examples/minio && $(foreach v,$(wildcard examples/minio/*.go),go build -mod=mod -o ${TMPDIR}/$(basename $(v)) $(notdir $(v)) || exit 1;)
+
+functional-test:
+        @GO111MODULE=on go build -race functional_tests.go
+        @SERVER_ENDPOINT=localhost:9000 ACCESS_KEY=minioadmin SECRET_KEY=minioadmin ENABLE_HTTPS=1 MINT_MODE=full ./functional_tests
+
+clean:
+        @echo "Cleaning up all the generated files"
+        @find . -name '*.test' | xargs rm -fv
+        @find . -name '*~' | xargs rm -fv
diff --git a/vendor/github.com/minio/minio-go/v7/NOTICE b/vendor/github.com/minio/minio-go/v7/NOTICE
new file mode 100644
index 0000000..1e8fd3b
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/NOTICE
@@ -0,0 +1,9 @@
+MinIO Cloud Storage, (C) 2014-2020 MinIO, Inc.
+
+This product includes software developed at MinIO, Inc.
+(https://min.io/).
+
+The MinIO project contains unmodified/modified subcomponents too with
+separate copyright notices and license terms. Your use of the source
+code for these subcomponents is subject to the terms and conditions
+of Apache License Version 2.0
diff --git a/vendor/github.com/minio/minio-go/v7/README.md b/vendor/github.com/minio/minio-go/v7/README.md
new file mode 100644
index 0000000..82f70a1
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/README.md
@@ -0,0 +1,312 @@
+# MinIO Go Client SDK for Amazon S3 Compatible Cloud Storage [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io) [![Sourcegraph](https://sourcegraph.com/github.com/minio/minio-go/-/badge.svg)](https://sourcegraph.com/github.com/minio/minio-go?badge) [![Apache V2 License](https://img.shields.io/badge/license-Apache%20V2-blue.svg)](https://github.com/minio/minio-go/blob/master/LICENSE)
+
+The MinIO Go Client SDK provides straightforward APIs to access any Amazon S3 compatible object storage.
+
+This Quickstart Guide covers how to install the MinIO client SDK, connect to MinIO, and create a sample file uploader.
+For a complete list of APIs and examples, see the [godoc documentation](https://pkg.go.dev/github.com/minio/minio-go/v7) or [Go Client API Reference](https://min.io/docs/minio/linux/developers/go/API.html).
+
+These examples presume a working [Go development environment](https://golang.org/doc/install) and the [MinIO `mc` command line tool](https://min.io/docs/minio/linux/reference/minio-mc.html).
+
+## Download from Github
+
+From your project directory:
+
+```sh
+go get github.com/minio/minio-go/v7
+```
+
+## Initialize a MinIO Client Object
+
+The MinIO client requires the following parameters to connect to an Amazon S3 compatible object storage:
+
+| Parameter         | Description                                                |
+| ----------------- | ---------------------------------------------------------- |
+| `endpoint`        | URL to object storage service.                             |
+| `_minio.Options_` | All the options such as credentials, custom transport etc. |
+
+```go
+package main
+
+import (
+        "log"
+
+        "github.com/minio/minio-go/v7"
+        "github.com/minio/minio-go/v7/pkg/credentials"
+)
+
+func main() {
+        endpoint := "play.min.io"
+        accessKeyID := "Q3AM3UQ867SPQQA43P2F"
+        secretAccessKey := "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG"
+        useSSL := true
+
+        // Initialize minio client object.
+        minioClient, err := minio.New(endpoint, &minio.Options{
+                Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
+                Secure: useSSL,
+        })
+        if err != nil {
+                log.Fatalln(err)
+        }
+
+        log.Printf("%#v\n", minioClient) // minioClient is now set up
+}
+```
+
+## Example - File Uploader
+
+This sample code connects to an object storage server, creates a bucket, and uploads a file to the bucket.
+It uses the MinIO `play` server, a public MinIO cluster located at [https://play.min.io](https://play.min.io).
+
+The `play` server runs the latest stable version of MinIO and may be used for testing and development.
+The access credentials shown in this example are open to the public and all data uploaded to `play` should be considered public and non-protected.
+
+### FileUploader.go
+
+This example does the following:
+
+- Connects to the MinIO `play` server using the provided credentials.
+- Creates a bucket named `testbucket`.
+- Uploads a file named `testdata` from `/tmp`.
+- Verifies the file was created using `mc ls`.
+
+```go
+// FileUploader.go MinIO example
+package main
+
+import (
+        "context"
+        "log"
+
+        "github.com/minio/minio-go/v7"
+        "github.com/minio/minio-go/v7/pkg/credentials"
+)
+
+func main() {
+        ctx := context.Background()
+        endpoint := "play.min.io"
+        accessKeyID := "Q3AM3UQ867SPQQA43P2F"
+        secretAccessKey := "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG"
+        useSSL := true
+
+        // Initialize minio client object.
+        minioClient, err := minio.New(endpoint, &minio.Options{
+                Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
+                Secure: useSSL,
+        })
+        if err != nil {
+                log.Fatalln(err)
+        }
+
+        // Make a new bucket called testbucket.
+        bucketName := "testbucket"
+        location := "us-east-1"
+
+        err = minioClient.MakeBucket(ctx, bucketName, minio.MakeBucketOptions{Region: location})
+        if err != nil {
+                // Check to see if we already own this bucket (which happens if you run this twice)
+                exists, errBucketExists := minioClient.BucketExists(ctx, bucketName)
+                if errBucketExists == nil && exists {
+                        log.Printf("We already own %s\n", bucketName)
+                } else {
+                        log.Fatalln(err)
+                }
+        } else {
+                log.Printf("Successfully created %s\n", bucketName)
+        }
+
+        // Upload the test file
+        // Change the value of filePath if the file is in another location
+        objectName := "testdata"
+        filePath := "/tmp/testdata"
+        contentType := "application/octet-stream"
+
+        // Upload the test file with FPutObject
+        info, err := minioClient.FPutObject(ctx, bucketName, objectName, filePath, minio.PutObjectOptions{ContentType: contentType})
+        if err != nil {
+                log.Fatalln(err)
+        }
+
+        log.Printf("Successfully uploaded %s of size %d\n", objectName, info.Size)
+}
+```
+
+**1. Create a test file containing data:**
+
+You can do this with `dd` on Linux or macOS systems:
+
+```sh
+dd if=/dev/urandom of=/tmp/testdata bs=2048 count=10
+```
+
+or `fsutil` on Windows:
+
+```sh
+fsutil file createnew "C:\Users\<username>\Desktop\sample.txt" 20480
+```
+
+**2. Run FileUploader with the following commands:**
+
+```sh
+go mod init example/FileUploader
+go get github.com/minio/minio-go/v7
+go get github.com/minio/minio-go/v7/pkg/credentials
+go run FileUploader.go
+```
+
+The output resembles the following:
+
+```sh
+2023/11/01 14:27:55 Successfully created testbucket
+2023/11/01 14:27:55 Successfully uploaded testdata of size 20480
+```
+
+**3. Verify the Uploaded File With `mc ls`:**
+
+```sh
+mc ls play/testbucket
+[2023-11-01 14:27:55 UTC]  20KiB STANDARD TestDataFile
+```
+
+## API Reference
+
+The full API Reference is available here.
+
+* [Complete API Reference](https://min.io/docs/minio/linux/developers/go/API.html)
+
+### API Reference : Bucket Operations
+
+* [`MakeBucket`](https://min.io/docs/minio/linux/developers/go/API.html#MakeBucket)
+* [`ListBuckets`](https://min.io/docs/minio/linux/developers/go/API.html#ListBuckets)
+* [`BucketExists`](https://min.io/docs/minio/linux/developers/go/API.html#BucketExists)
+* [`RemoveBucket`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveBucket)
+* [`ListObjects`](https://min.io/docs/minio/linux/developers/go/API.html#ListObjects)
+* [`ListIncompleteUploads`](https://min.io/docs/minio/linux/developers/go/API.html#ListIncompleteUploads)
+
+### API Reference : Bucket policy Operations
+
+* [`SetBucketPolicy`](https://min.io/docs/minio/linux/developers/go/API.html#SetBucketPolicy)
+* [`GetBucketPolicy`](https://min.io/docs/minio/linux/developers/go/API.html#GetBucketPolicy)
+
+### API Reference : Bucket notification Operations
+
+* [`SetBucketNotification`](https://min.io/docs/minio/linux/developers/go/API.html#SetBucketNotification)
+* [`GetBucketNotification`](https://min.io/docs/minio/linux/developers/go/API.html#GetBucketNotification)
+* [`RemoveAllBucketNotification`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveAllBucketNotification)
+* [`ListenBucketNotification`](https://min.io/docs/minio/linux/developers/go/API.html#ListenBucketNotification) (MinIO Extension)
+* [`ListenNotification`](https://min.io/docs/minio/linux/developers/go/API.html#ListenNotification) (MinIO Extension)
+
+### API Reference : File Object Operations
+
+* [`FPutObject`](https://min.io/docs/minio/linux/developers/go/API.html#FPutObject)
+* [`FGetObject`](https://min.io/docs/minio/linux/developers/go/API.html#FGetObject)
+
+### API Reference : Object Operations
+
+* [`GetObject`](https://min.io/docs/minio/linux/developers/go/API.html#GetObject)
+* [`PutObject`](https://min.io/docs/minio/linux/developers/go/API.html#PutObject)
+* [`PutObjectStreaming`](https://min.io/docs/minio/linux/developers/go/API.html#PutObjectStreaming)
+* [`StatObject`](https://min.io/docs/minio/linux/developers/go/API.html#StatObject)
+* [`CopyObject`](https://min.io/docs/minio/linux/developers/go/API.html#CopyObject)
+* [`RemoveObject`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveObject)
+* [`RemoveObjects`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveObjects)
+* [`RemoveIncompleteUpload`](https://min.io/docs/minio/linux/developers/go/API.html#RemoveIncompleteUpload)
+* [`SelectObjectContent`](https://min.io/docs/minio/linux/developers/go/API.html#SelectObjectContent)
+
+### API Reference : Presigned Operations
+
+* [`PresignedGetObject`](https://min.io/docs/minio/linux/developers/go/API.html#PresignedGetObject)
+* [`PresignedPutObject`](https://min.io/docs/minio/linux/developers/go/API.html#PresignedPutObject)
+* [`PresignedHeadObject`](https://min.io/docs/minio/linux/developers/go/API.html#PresignedHeadObject)
+* [`PresignedPostPolicy`](https://min.io/docs/minio/linux/developers/go/API.html#PresignedPostPolicy)
+
+### API Reference : Client custom settings
+
+* [`SetAppInfo`](https://min.io/docs/minio/linux/developers/go/API.html#SetAppInfo)
+* [`TraceOn`](https://min.io/docs/minio/linux/developers/go/API.html#TraceOn)
+* [`TraceOff`](https://min.io/docs/minio/linux/developers/go/API.html#TraceOff)
+
+## Full Examples
+
+### Full Examples : Bucket Operations
+
+* [makebucket.go](https://github.com/minio/minio-go/blob/master/examples/s3/makebucket.go)
+* [listbuckets.go](https://github.com/minio/minio-go/blob/master/examples/s3/listbuckets.go)
+* [bucketexists.go](https://github.com/minio/minio-go/blob/master/examples/s3/bucketexists.go)
+* [removebucket.go](https://github.com/minio/minio-go/blob/master/examples/s3/removebucket.go)
+* [listobjects.go](https://github.com/minio/minio-go/blob/master/examples/s3/listobjects.go)
+* [listobjectsV2.go](https://github.com/minio/minio-go/blob/master/examples/s3/listobjectsV2.go)
+* [listincompleteuploads.go](https://github.com/minio/minio-go/blob/master/examples/s3/listincompleteuploads.go)
+
+### Full Examples : Bucket policy Operations
+
+* [setbucketpolicy.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketpolicy.go)
+* [getbucketpolicy.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketpolicy.go)
+* [listbucketpolicies.go](https://github.com/minio/minio-go/blob/master/examples/s3/listbucketpolicies.go)
+
+### Full Examples : Bucket lifecycle Operations
+
+* [setbucketlifecycle.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketlifecycle.go)
+* [getbucketlifecycle.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketlifecycle.go)
+
+### Full Examples : Bucket encryption Operations
+
+* [setbucketencryption.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketencryption.go)
+* [getbucketencryption.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketencryption.go)
+* [deletebucketencryption.go](https://github.com/minio/minio-go/blob/master/examples/s3/deletebucketencryption.go)
+
+### Full Examples : Bucket replication Operations
+
+* [setbucketreplication.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketreplication.go)
+* [getbucketreplication.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketreplication.go)
+* [removebucketreplication.go](https://github.com/minio/minio-go/blob/master/examples/s3/removebucketreplication.go)
+
+### Full Examples : Bucket notification Operations
+
+* [setbucketnotification.go](https://github.com/minio/minio-go/blob/master/examples/s3/setbucketnotification.go)
+* [getbucketnotification.go](https://github.com/minio/minio-go/blob/master/examples/s3/getbucketnotification.go)
+* [removeallbucketnotification.go](https://github.com/minio/minio-go/blob/master/examples/s3/removeallbucketnotification.go)
+* [listenbucketnotification.go](https://github.com/minio/minio-go/blob/master/examples/minio/listenbucketnotification.go) (MinIO Extension)
+* [listennotification.go](https://github.com/minio/minio-go/blob/master/examples/minio/listen-notification.go) (MinIO Extension)
+
+### Full Examples : File Object Operations
+
+* [fputobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/fputobject.go)
+* [fgetobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/fgetobject.go)
+
+### Full Examples : Object Operations
+
+* [putobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/putobject.go)
+* [getobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/getobject.go)
+* [statobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/statobject.go)
+* [copyobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/copyobject.go)
+* [removeobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/removeobject.go)
+* [removeincompleteupload.go](https://github.com/minio/minio-go/blob/master/examples/s3/removeincompleteupload.go)
+* [removeobjects.go](https://github.com/minio/minio-go/blob/master/examples/s3/removeobjects.go)
+
+### Full Examples : Encrypted Object Operations
+
+* [put-encrypted-object.go](https://github.com/minio/minio-go/blob/master/examples/s3/put-encrypted-object.go)
+* [get-encrypted-object.go](https://github.com/minio/minio-go/blob/master/examples/s3/get-encrypted-object.go)
+* [fput-encrypted-object.go](https://github.com/minio/minio-go/blob/master/examples/s3/fputencrypted-object.go)
+
+### Full Examples : Presigned Operations
+
+* [presignedgetobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/presignedgetobject.go)
+* [presignedputobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/presignedputobject.go)
+* [presignedheadobject.go](https://github.com/minio/minio-go/blob/master/examples/s3/presignedheadobject.go)
+* [presignedpostpolicy.go](https://github.com/minio/minio-go/blob/master/examples/s3/presignedpostpolicy.go)
+
+## Explore Further
+
+* [Godoc Documentation](https://pkg.go.dev/github.com/minio/minio-go/v7)
+* [Complete Documentation](https://min.io/docs/minio/kubernetes/upstream/index.html)
+* [MinIO Go Client SDK API Reference](https://min.io/docs/minio/linux/developers/go/API.html)
+
+## Contribute
+
+[Contributors Guide](https://github.com/minio/minio-go/blob/master/CONTRIBUTING.md)
+
+## License
+
+This SDK is distributed under the [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0), see [LICENSE](https://github.com/minio/minio-go/blob/master/LICENSE) and [NOTICE](https://github.com/minio/minio-go/blob/master/NOTICE) for more information.
diff --git a/vendor/github.com/minio/minio-go/v7/api-bucket-encryption.go b/vendor/github.com/minio/minio-go/v7/api-bucket-encryption.go
new file mode 100644
index 0000000..24f94e0
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-bucket-encryption.go
@@ -0,0 +1,134 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2020 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/xml"
+        "net/http"
+        "net/url"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+        "github.com/minio/minio-go/v7/pkg/sse"
+)
+
+// SetBucketEncryption sets the default encryption configuration on an existing bucket.
+func (c *Client) SetBucketEncryption(ctx context.Context, bucketName string, config *sse.Configuration) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+
+        if config == nil {
+                return errInvalidArgument("configuration cannot be empty")
+        }
+
+        buf, err := xml.Marshal(config)
+        if err != nil {
+                return err
+        }
+
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("encryption", "")
+
+        // Content-length is mandatory to set a default encryption configuration
+        reqMetadata := requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentBody:      bytes.NewReader(buf),
+                contentLength:    int64(len(buf)),
+                contentMD5Base64: sumMD5Base64(buf),
+        }
+
+        // Execute PUT to upload a new bucket default encryption configuration.
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp.StatusCode != http.StatusOK {
+                return httpRespToErrorResponse(resp, bucketName, "")
+        }
+        return nil
+}
+
+// RemoveBucketEncryption removes the default encryption configuration on a bucket with a context to control cancellations and timeouts.
+func (c *Client) RemoveBucketEncryption(ctx context.Context, bucketName string) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("encryption", "")
+
+        // DELETE default encryption configuration on a bucket.
+        resp, err := c.executeMethod(ctx, http.MethodDelete, requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
+                return httpRespToErrorResponse(resp, bucketName, "")
+        }
+        return nil
+}
+
+// GetBucketEncryption gets the default encryption configuration
+// on an existing bucket with a context to control cancellations and timeouts.
+func (c *Client) GetBucketEncryption(ctx context.Context, bucketName string) (*sse.Configuration, error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return nil, err
+        }
+
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("encryption", "")
+
+        // Execute GET on bucket to get the default encryption configuration.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:  bucketName,
+                queryValues: urlValues,
+        })
+
+        defer closeResponse(resp)
+        if err != nil {
+                return nil, err
+        }
+
+        if resp.StatusCode != http.StatusOK {
+                return nil, httpRespToErrorResponse(resp, bucketName, "")
+        }
+
+        encryptionConfig := &sse.Configuration{}
+        if err = xmlDecoder(resp.Body, encryptionConfig); err != nil {
+                return nil, err
+        }
+
+        return encryptionConfig, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-bucket-lifecycle.go b/vendor/github.com/minio/minio-go/v7/api-bucket-lifecycle.go
new file mode 100644
index 0000000..fec5cec
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-bucket-lifecycle.go
@@ -0,0 +1,169 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2020 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/xml"
+        "io"
+        "net/http"
+        "net/url"
+        "time"
+
+        "github.com/minio/minio-go/v7/pkg/lifecycle"
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// SetBucketLifecycle set the lifecycle on an existing bucket.
+func (c *Client) SetBucketLifecycle(ctx context.Context, bucketName string, config *lifecycle.Configuration) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+
+        // If lifecycle is empty then delete it.
+        if config.Empty() {
+                return c.removeBucketLifecycle(ctx, bucketName)
+        }
+
+        buf, err := xml.Marshal(config)
+        if err != nil {
+                return err
+        }
+
+        // Save the updated lifecycle.
+        return c.putBucketLifecycle(ctx, bucketName, buf)
+}
+
+// Saves a new bucket lifecycle.
+func (c *Client) putBucketLifecycle(ctx context.Context, bucketName string, buf []byte) error {
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("lifecycle", "")
+
+        // Content-length is mandatory for put lifecycle request
+        reqMetadata := requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentBody:      bytes.NewReader(buf),
+                contentLength:    int64(len(buf)),
+                contentMD5Base64: sumMD5Base64(buf),
+        }
+
+        // Execute PUT to upload a new bucket lifecycle.
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+        return nil
+}
+
+// Remove lifecycle from a bucket.
+func (c *Client) removeBucketLifecycle(ctx context.Context, bucketName string) error {
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("lifecycle", "")
+
+        // Execute DELETE on objectName.
+        resp, err := c.executeMethod(ctx, http.MethodDelete, requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        return nil
+}
+
+// GetBucketLifecycle fetch bucket lifecycle configuration
+func (c *Client) GetBucketLifecycle(ctx context.Context, bucketName string) (*lifecycle.Configuration, error) {
+        lc, _, err := c.GetBucketLifecycleWithInfo(ctx, bucketName)
+        return lc, err
+}
+
+// GetBucketLifecycleWithInfo fetch bucket lifecycle configuration along with when it was last updated
+func (c *Client) GetBucketLifecycleWithInfo(ctx context.Context, bucketName string) (*lifecycle.Configuration, time.Time, error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return nil, time.Time{}, err
+        }
+
+        bucketLifecycle, updatedAt, err := c.getBucketLifecycle(ctx, bucketName)
+        if err != nil {
+                return nil, time.Time{}, err
+        }
+
+        config := lifecycle.NewConfiguration()
+        if err = xml.Unmarshal(bucketLifecycle, config); err != nil {
+                return nil, time.Time{}, err
+        }
+        return config, updatedAt, nil
+}
+
+// Request server for current bucket lifecycle.
+func (c *Client) getBucketLifecycle(ctx context.Context, bucketName string) ([]byte, time.Time, error) {
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("lifecycle", "")
+        urlValues.Set("withUpdatedAt", "true")
+
+        // Execute GET on bucket to get lifecycle.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:  bucketName,
+                queryValues: urlValues,
+        })
+
+        defer closeResponse(resp)
+        if err != nil {
+                return nil, time.Time{}, err
+        }
+
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return nil, time.Time{}, httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+
+        lcBytes, err := io.ReadAll(resp.Body)
+        if err != nil {
+                return nil, time.Time{}, err
+        }
+
+        const minIOLifecycleCfgUpdatedAt = "X-Minio-LifecycleConfig-UpdatedAt"
+        var updatedAt time.Time
+        if timeStr := resp.Header.Get(minIOLifecycleCfgUpdatedAt); timeStr != "" {
+                updatedAt, err = time.Parse(iso8601DateFormat, timeStr)
+                if err != nil {
+                        return nil, time.Time{}, err
+                }
+        }
+
+        return lcBytes, updatedAt, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-bucket-notification.go b/vendor/github.com/minio/minio-go/v7/api-bucket-notification.go
new file mode 100644
index 0000000..8de5c01
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-bucket-notification.go
@@ -0,0 +1,261 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2017-2020 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 minio
+
+import (
+        "bufio"
+        "bytes"
+        "context"
+        "encoding/xml"
+        "net/http"
+        "net/url"
+        "time"
+
+        jsoniter "github.com/json-iterator/go"
+        "github.com/minio/minio-go/v7/pkg/notification"
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// SetBucketNotification saves a new bucket notification with a context to control cancellations and timeouts.
+func (c *Client) SetBucketNotification(ctx context.Context, bucketName string, config notification.Configuration) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("notification", "")
+
+        notifBytes, err := xml.Marshal(&config)
+        if err != nil {
+                return err
+        }
+
+        notifBuffer := bytes.NewReader(notifBytes)
+        reqMetadata := requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentBody:      notifBuffer,
+                contentLength:    int64(len(notifBytes)),
+                contentMD5Base64: sumMD5Base64(notifBytes),
+                contentSHA256Hex: sum256Hex(notifBytes),
+        }
+
+        // Execute PUT to upload a new bucket notification.
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+        return nil
+}
+
+// RemoveAllBucketNotification - Remove bucket notification clears all previously specified config
+func (c *Client) RemoveAllBucketNotification(ctx context.Context, bucketName string) error {
+        return c.SetBucketNotification(ctx, bucketName, notification.Configuration{})
+}
+
+// GetBucketNotification returns current bucket notification configuration
+func (c *Client) GetBucketNotification(ctx context.Context, bucketName string) (bucketNotification notification.Configuration, err error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return notification.Configuration{}, err
+        }
+        return c.getBucketNotification(ctx, bucketName)
+}
+
+// Request server for notification rules.
+func (c *Client) getBucketNotification(ctx context.Context, bucketName string) (notification.Configuration, error) {
+        urlValues := make(url.Values)
+        urlValues.Set("notification", "")
+
+        // Execute GET on bucket to list objects.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+
+        defer closeResponse(resp)
+        if err != nil {
+                return notification.Configuration{}, err
+        }
+        return processBucketNotificationResponse(bucketName, resp)
+}
+
+// processes the GetNotification http response from the server.
+func processBucketNotificationResponse(bucketName string, resp *http.Response) (notification.Configuration, error) {
+        if resp.StatusCode != http.StatusOK {
+                errResponse := httpRespToErrorResponse(resp, bucketName, "")
+                return notification.Configuration{}, errResponse
+        }
+        var bucketNotification notification.Configuration
+        err := xmlDecoder(resp.Body, &bucketNotification)
+        if err != nil {
+                return notification.Configuration{}, err
+        }
+        return bucketNotification, nil
+}
+
+// ListenNotification listen for all events, this is a MinIO specific API
+func (c *Client) ListenNotification(ctx context.Context, prefix, suffix string, events []string) <-chan notification.Info {
+        return c.ListenBucketNotification(ctx, "", prefix, suffix, events)
+}
+
+// ListenBucketNotification listen for bucket events, this is a MinIO specific API
+func (c *Client) ListenBucketNotification(ctx context.Context, bucketName, prefix, suffix string, events []string) <-chan notification.Info {
+        notificationInfoCh := make(chan notification.Info, 1)
+        const notificationCapacity = 4 * 1024 * 1024
+        notificationEventBuffer := make([]byte, notificationCapacity)
+        // Only success, start a routine to start reading line by line.
+        go func(notificationInfoCh chan<- notification.Info) {
+                defer close(notificationInfoCh)
+
+                // Validate the bucket name.
+                if bucketName != "" {
+                        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                                select {
+                                case notificationInfoCh <- notification.Info{
+                                        Err: err,
+                                }:
+                                case <-ctx.Done():
+                                }
+                                return
+                        }
+                }
+
+                // Check ARN partition to verify if listening bucket is supported
+                if s3utils.IsAmazonEndpoint(*c.endpointURL) || s3utils.IsGoogleEndpoint(*c.endpointURL) {
+                        select {
+                        case notificationInfoCh <- notification.Info{
+                                Err: errAPINotSupported("Listening for bucket notification is specific only to `minio` server endpoints"),
+                        }:
+                        case <-ctx.Done():
+                        }
+                        return
+                }
+
+                // Continuously run and listen on bucket notification.
+                // Create a done channel to control 'ListObjects' go routine.
+                retryDoneCh := make(chan struct{}, 1)
+
+                // Indicate to our routine to exit cleanly upon return.
+                defer close(retryDoneCh)
+
+                // Prepare urlValues to pass into the request on every loop
+                urlValues := make(url.Values)
+                urlValues.Set("ping", "10")
+                urlValues.Set("prefix", prefix)
+                urlValues.Set("suffix", suffix)
+                urlValues["events"] = events
+
+                // Wait on the jitter retry loop.
+                for range c.newRetryTimerContinous(time.Second, time.Second*30, MaxJitter, retryDoneCh) {
+                        // Execute GET on bucket to list objects.
+                        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                                bucketName:       bucketName,
+                                queryValues:      urlValues,
+                                contentSHA256Hex: emptySHA256Hex,
+                        })
+                        if err != nil {
+                                select {
+                                case notificationInfoCh <- notification.Info{
+                                        Err: err,
+                                }:
+                                case <-ctx.Done():
+                                }
+                                return
+                        }
+
+                        // Validate http response, upon error return quickly.
+                        if resp.StatusCode != http.StatusOK {
+                                errResponse := httpRespToErrorResponse(resp, bucketName, "")
+                                select {
+                                case notificationInfoCh <- notification.Info{
+                                        Err: errResponse,
+                                }:
+                                case <-ctx.Done():
+                                }
+                                return
+                        }
+
+                        // Initialize a new bufio scanner, to read line by line.
+                        bio := bufio.NewScanner(resp.Body)
+
+                        // Use a higher buffer to support unexpected
+                        // caching done by proxies
+                        bio.Buffer(notificationEventBuffer, notificationCapacity)
+                        json := jsoniter.ConfigCompatibleWithStandardLibrary
+
+                        // Unmarshal each line, returns marshaled values.
+                        for bio.Scan() {
+                                var notificationInfo notification.Info
+                                if err = json.Unmarshal(bio.Bytes(), &notificationInfo); err != nil {
+                                        // Unexpected error during json unmarshal, send
+                                        // the error to caller for actionable as needed.
+                                        select {
+                                        case notificationInfoCh <- notification.Info{
+                                                Err: err,
+                                        }:
+                                        case <-ctx.Done():
+                                                return
+                                        }
+                                        closeResponse(resp)
+                                        continue
+                                }
+
+                                // Empty events pinged from the server
+                                if len(notificationInfo.Records) == 0 && notificationInfo.Err == nil {
+                                        continue
+                                }
+
+                                // Send notificationInfo
+                                select {
+                                case notificationInfoCh <- notificationInfo:
+                                case <-ctx.Done():
+                                        closeResponse(resp)
+                                        return
+                                }
+                        }
+
+                        if err = bio.Err(); err != nil {
+                                select {
+                                case notificationInfoCh <- notification.Info{
+                                        Err: err,
+                                }:
+                                case <-ctx.Done():
+                                        return
+                                }
+                        }
+
+                        // Close current connection before looping further.
+                        closeResponse(resp)
+
+                }
+        }(notificationInfoCh)
+
+        // Returns the notification info channel, for caller to start reading from.
+        return notificationInfoCh
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-bucket-policy.go b/vendor/github.com/minio/minio-go/v7/api-bucket-policy.go
new file mode 100644
index 0000000..dbb5259
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-bucket-policy.go
@@ -0,0 +1,147 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2020 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 minio
+
+import (
+        "context"
+        "io"
+        "net/http"
+        "net/url"
+        "strings"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// SetBucketPolicy sets the access permissions on an existing bucket.
+func (c *Client) SetBucketPolicy(ctx context.Context, bucketName, policy string) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+
+        // If policy is empty then delete the bucket policy.
+        if policy == "" {
+                return c.removeBucketPolicy(ctx, bucketName)
+        }
+
+        // Save the updated policies.
+        return c.putBucketPolicy(ctx, bucketName, policy)
+}
+
+// Saves a new bucket policy.
+func (c *Client) putBucketPolicy(ctx context.Context, bucketName, policy string) error {
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("policy", "")
+
+        reqMetadata := requestMetadata{
+                bucketName:    bucketName,
+                queryValues:   urlValues,
+                contentBody:   strings.NewReader(policy),
+                contentLength: int64(len(policy)),
+        }
+
+        // Execute PUT to upload a new bucket policy.
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusOK {
+                        return httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+        return nil
+}
+
+// Removes all policies on a bucket.
+func (c *Client) removeBucketPolicy(ctx context.Context, bucketName string) error {
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("policy", "")
+
+        // Execute DELETE on objectName.
+        resp, err := c.executeMethod(ctx, http.MethodDelete, requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+
+        if resp.StatusCode != http.StatusNoContent {
+                return httpRespToErrorResponse(resp, bucketName, "")
+        }
+
+        return nil
+}
+
+// GetBucketPolicy returns the current policy
+func (c *Client) GetBucketPolicy(ctx context.Context, bucketName string) (string, error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return "", err
+        }
+        bucketPolicy, err := c.getBucketPolicy(ctx, bucketName)
+        if err != nil {
+                errResponse := ToErrorResponse(err)
+                if errResponse.Code == "NoSuchBucketPolicy" {
+                        return "", nil
+                }
+                return "", err
+        }
+        return bucketPolicy, nil
+}
+
+// Request server for current bucket policy.
+func (c *Client) getBucketPolicy(ctx context.Context, bucketName string) (string, error) {
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("policy", "")
+
+        // Execute GET on bucket to list objects.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+
+        defer closeResponse(resp)
+        if err != nil {
+                return "", err
+        }
+
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return "", httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+
+        bucketPolicyBuf, err := io.ReadAll(resp.Body)
+        if err != nil {
+                return "", err
+        }
+
+        policy := string(bucketPolicyBuf)
+        return policy, err
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-bucket-replication.go b/vendor/github.com/minio/minio-go/v7/api-bucket-replication.go
new file mode 100644
index 0000000..b12bb13
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-bucket-replication.go
@@ -0,0 +1,355 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2020 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/json"
+        "encoding/xml"
+        "io"
+        "net/http"
+        "net/url"
+        "time"
+
+        "github.com/google/uuid"
+        "github.com/minio/minio-go/v7/pkg/replication"
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// RemoveBucketReplication removes a replication config on an existing bucket.
+func (c *Client) RemoveBucketReplication(ctx context.Context, bucketName string) error {
+        return c.removeBucketReplication(ctx, bucketName)
+}
+
+// SetBucketReplication sets a replication config on an existing bucket.
+func (c *Client) SetBucketReplication(ctx context.Context, bucketName string, cfg replication.Config) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+
+        // If replication is empty then delete it.
+        if cfg.Empty() {
+                return c.removeBucketReplication(ctx, bucketName)
+        }
+        // Save the updated replication.
+        return c.putBucketReplication(ctx, bucketName, cfg)
+}
+
+// Saves a new bucket replication.
+func (c *Client) putBucketReplication(ctx context.Context, bucketName string, cfg replication.Config) error {
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("replication", "")
+        replication, err := xml.Marshal(cfg)
+        if err != nil {
+                return err
+        }
+
+        reqMetadata := requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentBody:      bytes.NewReader(replication),
+                contentLength:    int64(len(replication)),
+                contentMD5Base64: sumMD5Base64(replication),
+        }
+
+        // Execute PUT to upload a new bucket replication config.
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+
+        if resp.StatusCode != http.StatusOK {
+                return httpRespToErrorResponse(resp, bucketName, "")
+        }
+
+        return nil
+}
+
+// Remove replication from a bucket.
+func (c *Client) removeBucketReplication(ctx context.Context, bucketName string) error {
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("replication", "")
+
+        // Execute DELETE on objectName.
+        resp, err := c.executeMethod(ctx, http.MethodDelete, requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp.StatusCode != http.StatusOK {
+                return httpRespToErrorResponse(resp, bucketName, "")
+        }
+        return nil
+}
+
+// GetBucketReplication fetches bucket replication configuration.If config is not
+// found, returns empty config with nil error.
+func (c *Client) GetBucketReplication(ctx context.Context, bucketName string) (cfg replication.Config, err error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return cfg, err
+        }
+        bucketReplicationCfg, err := c.getBucketReplication(ctx, bucketName)
+        if err != nil {
+                errResponse := ToErrorResponse(err)
+                if errResponse.Code == "ReplicationConfigurationNotFoundError" {
+                        return cfg, nil
+                }
+                return cfg, err
+        }
+        return bucketReplicationCfg, nil
+}
+
+// Request server for current bucket replication config.
+func (c *Client) getBucketReplication(ctx context.Context, bucketName string) (cfg replication.Config, err error) {
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("replication", "")
+
+        // Execute GET on bucket to get replication config.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:  bucketName,
+                queryValues: urlValues,
+        })
+
+        defer closeResponse(resp)
+        if err != nil {
+                return cfg, err
+        }
+
+        if resp.StatusCode != http.StatusOK {
+                return cfg, httpRespToErrorResponse(resp, bucketName, "")
+        }
+
+        if err = xmlDecoder(resp.Body, &cfg); err != nil {
+                return cfg, err
+        }
+
+        return cfg, nil
+}
+
+// GetBucketReplicationMetrics fetches bucket replication status metrics
+func (c *Client) GetBucketReplicationMetrics(ctx context.Context, bucketName string) (s replication.Metrics, err error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return s, err
+        }
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("replication-metrics", "")
+
+        // Execute GET on bucket to get replication config.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:  bucketName,
+                queryValues: urlValues,
+        })
+
+        defer closeResponse(resp)
+        if err != nil {
+                return s, err
+        }
+
+        if resp.StatusCode != http.StatusOK {
+                return s, httpRespToErrorResponse(resp, bucketName, "")
+        }
+        respBytes, err := io.ReadAll(resp.Body)
+        if err != nil {
+                return s, err
+        }
+
+        if err := json.Unmarshal(respBytes, &s); err != nil {
+                return s, err
+        }
+        return s, nil
+}
+
+// mustGetUUID - get a random UUID.
+func mustGetUUID() string {
+        u, err := uuid.NewRandom()
+        if err != nil {
+                return ""
+        }
+        return u.String()
+}
+
+// ResetBucketReplication kicks off replication of previously replicated objects if ExistingObjectReplication
+// is enabled in the replication config
+func (c *Client) ResetBucketReplication(ctx context.Context, bucketName string, olderThan time.Duration) (rID string, err error) {
+        rID = mustGetUUID()
+        _, err = c.resetBucketReplicationOnTarget(ctx, bucketName, olderThan, "", rID)
+        if err != nil {
+                return rID, err
+        }
+        return rID, nil
+}
+
+// ResetBucketReplicationOnTarget kicks off replication of previously replicated objects if
+// ExistingObjectReplication is enabled in the replication config
+func (c *Client) ResetBucketReplicationOnTarget(ctx context.Context, bucketName string, olderThan time.Duration, tgtArn string) (replication.ResyncTargetsInfo, error) {
+        return c.resetBucketReplicationOnTarget(ctx, bucketName, olderThan, tgtArn, mustGetUUID())
+}
+
+// ResetBucketReplication kicks off replication of previously replicated objects if ExistingObjectReplication
+// is enabled in the replication config
+func (c *Client) resetBucketReplicationOnTarget(ctx context.Context, bucketName string, olderThan time.Duration, tgtArn, resetID string) (rinfo replication.ResyncTargetsInfo, err error) {
+        // Input validation.
+        if err = s3utils.CheckValidBucketName(bucketName); err != nil {
+                return
+        }
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("replication-reset", "")
+        if olderThan > 0 {
+                urlValues.Set("older-than", olderThan.String())
+        }
+        if tgtArn != "" {
+                urlValues.Set("arn", tgtArn)
+        }
+        urlValues.Set("reset-id", resetID)
+        // Execute GET on bucket to get replication config.
+        resp, err := c.executeMethod(ctx, http.MethodPut, requestMetadata{
+                bucketName:  bucketName,
+                queryValues: urlValues,
+        })
+
+        defer closeResponse(resp)
+        if err != nil {
+                return rinfo, err
+        }
+
+        if resp.StatusCode != http.StatusOK {
+                return rinfo, httpRespToErrorResponse(resp, bucketName, "")
+        }
+
+        if err = json.NewDecoder(resp.Body).Decode(&rinfo); err != nil {
+                return rinfo, err
+        }
+        return rinfo, nil
+}
+
+// GetBucketReplicationResyncStatus gets the status of replication resync
+func (c *Client) GetBucketReplicationResyncStatus(ctx context.Context, bucketName, arn string) (rinfo replication.ResyncTargetsInfo, err error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return rinfo, err
+        }
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("replication-reset-status", "")
+        if arn != "" {
+                urlValues.Set("arn", arn)
+        }
+        // Execute GET on bucket to get replication config.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:  bucketName,
+                queryValues: urlValues,
+        })
+
+        defer closeResponse(resp)
+        if err != nil {
+                return rinfo, err
+        }
+
+        if resp.StatusCode != http.StatusOK {
+                return rinfo, httpRespToErrorResponse(resp, bucketName, "")
+        }
+
+        if err = json.NewDecoder(resp.Body).Decode(&rinfo); err != nil {
+                return rinfo, err
+        }
+        return rinfo, nil
+}
+
+// GetBucketReplicationMetricsV2 fetches bucket replication status metrics
+func (c *Client) GetBucketReplicationMetricsV2(ctx context.Context, bucketName string) (s replication.MetricsV2, err error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return s, err
+        }
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("replication-metrics", "2")
+
+        // Execute GET on bucket to get replication metrics.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:  bucketName,
+                queryValues: urlValues,
+        })
+
+        defer closeResponse(resp)
+        if err != nil {
+                return s, err
+        }
+
+        if resp.StatusCode != http.StatusOK {
+                return s, httpRespToErrorResponse(resp, bucketName, "")
+        }
+        respBytes, err := io.ReadAll(resp.Body)
+        if err != nil {
+                return s, err
+        }
+
+        if err := json.Unmarshal(respBytes, &s); err != nil {
+                return s, err
+        }
+        return s, nil
+}
+
+// CheckBucketReplication validates if replication is set up properly for a bucket
+func (c *Client) CheckBucketReplication(ctx context.Context, bucketName string) (err error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("replication-check", "")
+
+        // Execute GET on bucket to get replication config.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:  bucketName,
+                queryValues: urlValues,
+        })
+
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+
+        if resp.StatusCode != http.StatusOK {
+                return httpRespToErrorResponse(resp, bucketName, "")
+        }
+        return nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-bucket-tagging.go b/vendor/github.com/minio/minio-go/v7/api-bucket-tagging.go
new file mode 100644
index 0000000..86d7429
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-bucket-tagging.go
@@ -0,0 +1,134 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2020 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/xml"
+        "errors"
+        "io"
+        "net/http"
+        "net/url"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+        "github.com/minio/minio-go/v7/pkg/tags"
+)
+
+// GetBucketTagging fetch tagging configuration for a bucket with a
+// context to control cancellations and timeouts.
+func (c *Client) GetBucketTagging(ctx context.Context, bucketName string) (*tags.Tags, error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return nil, err
+        }
+
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("tagging", "")
+
+        // Execute GET on bucket to get tagging configuration.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:  bucketName,
+                queryValues: urlValues,
+        })
+
+        defer closeResponse(resp)
+        if err != nil {
+                return nil, err
+        }
+
+        if resp.StatusCode != http.StatusOK {
+                return nil, httpRespToErrorResponse(resp, bucketName, "")
+        }
+
+        defer io.Copy(io.Discard, resp.Body)
+        return tags.ParseBucketXML(resp.Body)
+}
+
+// SetBucketTagging sets tagging configuration for a bucket
+// with a context to control cancellations and timeouts.
+func (c *Client) SetBucketTagging(ctx context.Context, bucketName string, tags *tags.Tags) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+
+        if tags == nil {
+                return errors.New("nil tags passed")
+        }
+
+        buf, err := xml.Marshal(tags)
+        if err != nil {
+                return err
+        }
+
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("tagging", "")
+
+        // Content-length is mandatory to set a default encryption configuration
+        reqMetadata := requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentBody:      bytes.NewReader(buf),
+                contentLength:    int64(len(buf)),
+                contentMD5Base64: sumMD5Base64(buf),
+        }
+
+        // Execute PUT on bucket to put tagging configuration.
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
+                return httpRespToErrorResponse(resp, bucketName, "")
+        }
+        return nil
+}
+
+// RemoveBucketTagging removes tagging configuration for a
+// bucket with a context to control cancellations and timeouts.
+func (c *Client) RemoveBucketTagging(ctx context.Context, bucketName string) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("tagging", "")
+
+        // Execute DELETE on bucket to remove tagging configuration.
+        resp, err := c.executeMethod(ctx, http.MethodDelete, requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
+                return httpRespToErrorResponse(resp, bucketName, "")
+        }
+        return nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-bucket-versioning.go b/vendor/github.com/minio/minio-go/v7/api-bucket-versioning.go
new file mode 100644
index 0000000..8c84e4f
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-bucket-versioning.go
@@ -0,0 +1,146 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2020 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/xml"
+        "net/http"
+        "net/url"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// SetBucketVersioning sets a bucket versioning configuration
+func (c *Client) SetBucketVersioning(ctx context.Context, bucketName string, config BucketVersioningConfiguration) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+
+        buf, err := xml.Marshal(config)
+        if err != nil {
+                return err
+        }
+
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("versioning", "")
+
+        reqMetadata := requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentBody:      bytes.NewReader(buf),
+                contentLength:    int64(len(buf)),
+                contentMD5Base64: sumMD5Base64(buf),
+                contentSHA256Hex: sum256Hex(buf),
+        }
+
+        // Execute PUT to set a bucket versioning.
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+        return nil
+}
+
+// EnableVersioning - enable object versioning in given bucket.
+func (c *Client) EnableVersioning(ctx context.Context, bucketName string) error {
+        return c.SetBucketVersioning(ctx, bucketName, BucketVersioningConfiguration{Status: "Enabled"})
+}
+
+// SuspendVersioning - suspend object versioning in given bucket.
+func (c *Client) SuspendVersioning(ctx context.Context, bucketName string) error {
+        return c.SetBucketVersioning(ctx, bucketName, BucketVersioningConfiguration{Status: "Suspended"})
+}
+
+// ExcludedPrefix - holds individual prefixes excluded from being versioned.
+type ExcludedPrefix struct {
+        Prefix string
+}
+
+// BucketVersioningConfiguration is the versioning configuration structure
+type BucketVersioningConfiguration struct {
+        XMLName   xml.Name `xml:"VersioningConfiguration"`
+        Status    string   `xml:"Status"`
+        MFADelete string   `xml:"MfaDelete,omitempty"`
+        // MinIO extension - allows selective, prefix-level versioning exclusion.
+        // Requires versioning to be enabled
+        ExcludedPrefixes []ExcludedPrefix `xml:",omitempty"`
+        ExcludeFolders   bool             `xml:",omitempty"`
+}
+
+// Various supported states
+const (
+        Enabled = "Enabled"
+        // Disabled  State = "Disabled" only used by MFA Delete not supported yet.
+        Suspended = "Suspended"
+)
+
+// Enabled returns true if bucket versioning is enabled
+func (b BucketVersioningConfiguration) Enabled() bool {
+        return b.Status == Enabled
+}
+
+// Suspended returns true if bucket versioning is suspended
+func (b BucketVersioningConfiguration) Suspended() bool {
+        return b.Status == Suspended
+}
+
+// GetBucketVersioning gets the versioning configuration on
+// an existing bucket with a context to control cancellations and timeouts.
+func (c *Client) GetBucketVersioning(ctx context.Context, bucketName string) (BucketVersioningConfiguration, error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return BucketVersioningConfiguration{}, err
+        }
+
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("versioning", "")
+
+        // Execute GET on bucket to get the versioning configuration.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:  bucketName,
+                queryValues: urlValues,
+        })
+
+        defer closeResponse(resp)
+        if err != nil {
+                return BucketVersioningConfiguration{}, err
+        }
+
+        if resp.StatusCode != http.StatusOK {
+                return BucketVersioningConfiguration{}, httpRespToErrorResponse(resp, bucketName, "")
+        }
+
+        versioningConfig := BucketVersioningConfiguration{}
+        if err = xmlDecoder(resp.Body, &versioningConfig); err != nil {
+                return versioningConfig, err
+        }
+
+        return versioningConfig, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-compose-object.go b/vendor/github.com/minio/minio-go/v7/api-compose-object.go
new file mode 100644
index 0000000..e64a244
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-compose-object.go
@@ -0,0 +1,594 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2017, 2018 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 minio
+
+import (
+        "context"
+        "fmt"
+        "io"
+        "net/http"
+        "net/url"
+        "strconv"
+        "strings"
+        "time"
+
+        "github.com/google/uuid"
+        "github.com/minio/minio-go/v7/pkg/encrypt"
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// CopyDestOptions represents options specified by user for CopyObject/ComposeObject APIs
+type CopyDestOptions struct {
+        Bucket string // points to destination bucket
+        Object string // points to destination object
+
+        // `Encryption` is the key info for server-side-encryption with customer
+        // provided key. If it is nil, no encryption is performed.
+        Encryption encrypt.ServerSide
+
+        // `userMeta` is the user-metadata key-value pairs to be set on the
+        // destination. The keys are automatically prefixed with `x-amz-meta-`
+        // if needed. If nil is passed, and if only a single source (of any
+        // size) is provided in the ComposeObject call, then metadata from the
+        // source is copied to the destination.
+        // if no user-metadata is provided, it is copied from source
+        // (when there is only once source object in the compose
+        // request)
+        UserMetadata map[string]string
+        // UserMetadata is only set to destination if ReplaceMetadata is true
+        // other value is UserMetadata is ignored and we preserve src.UserMetadata
+        // NOTE: if you set this value to true and now metadata is present
+        // in UserMetadata your destination object will not have any metadata
+        // set.
+        ReplaceMetadata bool
+
+        // `userTags` is the user defined object tags to be set on destination.
+        // This will be set only if the `replaceTags` field is set to true.
+        // Otherwise this field is ignored
+        UserTags    map[string]string
+        ReplaceTags bool
+
+        // Specifies whether you want to apply a Legal Hold to the copied object.
+        LegalHold LegalHoldStatus
+
+        // Object Retention related fields
+        Mode            RetentionMode
+        RetainUntilDate time.Time
+
+        Size int64 // Needs to be specified if progress bar is specified.
+        // Progress of the entire copy operation will be sent here.
+        Progress io.Reader
+}
+
+// Process custom-metadata to remove a `x-amz-meta-` prefix if
+// present and validate that keys are distinct (after this
+// prefix removal).
+func filterCustomMeta(userMeta map[string]string) map[string]string {
+        m := make(map[string]string)
+        for k, v := range userMeta {
+                if strings.HasPrefix(strings.ToLower(k), "x-amz-meta-") {
+                        k = k[len("x-amz-meta-"):]
+                }
+                if _, ok := m[k]; ok {
+                        continue
+                }
+                m[k] = v
+        }
+        return m
+}
+
+// Marshal converts all the CopyDestOptions into their
+// equivalent HTTP header representation
+func (opts CopyDestOptions) Marshal(header http.Header) {
+        const replaceDirective = "REPLACE"
+        if opts.ReplaceTags {
+                header.Set(amzTaggingHeaderDirective, replaceDirective)
+                if tags := s3utils.TagEncode(opts.UserTags); tags != "" {
+                        header.Set(amzTaggingHeader, tags)
+                }
+        }
+
+        if opts.LegalHold != LegalHoldStatus("") {
+                header.Set(amzLegalHoldHeader, opts.LegalHold.String())
+        }
+
+        if opts.Mode != RetentionMode("") && !opts.RetainUntilDate.IsZero() {
+                header.Set(amzLockMode, opts.Mode.String())
+                header.Set(amzLockRetainUntil, opts.RetainUntilDate.Format(time.RFC3339))
+        }
+
+        if opts.Encryption != nil {
+                opts.Encryption.Marshal(header)
+        }
+
+        if opts.ReplaceMetadata {
+                header.Set("x-amz-metadata-directive", replaceDirective)
+                for k, v := range filterCustomMeta(opts.UserMetadata) {
+                        if isAmzHeader(k) || isStandardHeader(k) || isStorageClassHeader(k) {
+                                header.Set(k, v)
+                        } else {
+                                header.Set("x-amz-meta-"+k, v)
+                        }
+                }
+        }
+}
+
+// toDestinationInfo returns a validated copyOptions object.
+func (opts CopyDestOptions) validate() (err error) {
+        // Input validation.
+        if err = s3utils.CheckValidBucketName(opts.Bucket); err != nil {
+                return err
+        }
+        if err = s3utils.CheckValidObjectName(opts.Object); err != nil {
+                return err
+        }
+        if opts.Progress != nil && opts.Size < 0 {
+                return errInvalidArgument("For progress bar effective size needs to be specified")
+        }
+        return nil
+}
+
+// CopySrcOptions represents a source object to be copied, using
+// server-side copying APIs.
+type CopySrcOptions struct {
+        Bucket, Object       string
+        VersionID            string
+        MatchETag            string
+        NoMatchETag          string
+        MatchModifiedSince   time.Time
+        MatchUnmodifiedSince time.Time
+        MatchRange           bool
+        Start, End           int64
+        Encryption           encrypt.ServerSide
+}
+
+// Marshal converts all the CopySrcOptions into their
+// equivalent HTTP header representation
+func (opts CopySrcOptions) Marshal(header http.Header) {
+        // Set the source header
+        header.Set("x-amz-copy-source", s3utils.EncodePath(opts.Bucket+"/"+opts.Object))
+        if opts.VersionID != "" {
+                header.Set("x-amz-copy-source", s3utils.EncodePath(opts.Bucket+"/"+opts.Object)+"?versionId="+opts.VersionID)
+        }
+
+        if opts.MatchETag != "" {
+                header.Set("x-amz-copy-source-if-match", opts.MatchETag)
+        }
+        if opts.NoMatchETag != "" {
+                header.Set("x-amz-copy-source-if-none-match", opts.NoMatchETag)
+        }
+
+        if !opts.MatchModifiedSince.IsZero() {
+                header.Set("x-amz-copy-source-if-modified-since", opts.MatchModifiedSince.Format(http.TimeFormat))
+        }
+        if !opts.MatchUnmodifiedSince.IsZero() {
+                header.Set("x-amz-copy-source-if-unmodified-since", opts.MatchUnmodifiedSince.Format(http.TimeFormat))
+        }
+
+        if opts.Encryption != nil {
+                encrypt.SSECopy(opts.Encryption).Marshal(header)
+        }
+}
+
+func (opts CopySrcOptions) validate() (err error) {
+        // Input validation.
+        if err = s3utils.CheckValidBucketName(opts.Bucket); err != nil {
+                return err
+        }
+        if err = s3utils.CheckValidObjectName(opts.Object); err != nil {
+                return err
+        }
+        if opts.Start > opts.End || opts.Start < 0 {
+                return errInvalidArgument("start must be non-negative, and start must be at most end.")
+        }
+        return nil
+}
+
+// Low level implementation of CopyObject API, supports only upto 5GiB worth of copy.
+func (c *Client) copyObjectDo(ctx context.Context, srcBucket, srcObject, destBucket, destObject string,
+        metadata map[string]string, srcOpts CopySrcOptions, dstOpts PutObjectOptions,
+) (ObjectInfo, error) {
+        // Build headers.
+        headers := make(http.Header)
+
+        // Set all the metadata headers.
+        for k, v := range metadata {
+                headers.Set(k, v)
+        }
+        if !dstOpts.Internal.ReplicationStatus.Empty() {
+                headers.Set(amzBucketReplicationStatus, string(dstOpts.Internal.ReplicationStatus))
+        }
+        if !dstOpts.Internal.SourceMTime.IsZero() {
+                headers.Set(minIOBucketSourceMTime, dstOpts.Internal.SourceMTime.Format(time.RFC3339Nano))
+        }
+        if dstOpts.Internal.SourceETag != "" {
+                headers.Set(minIOBucketSourceETag, dstOpts.Internal.SourceETag)
+        }
+        if dstOpts.Internal.ReplicationRequest {
+                headers.Set(minIOBucketReplicationRequest, "true")
+        }
+        if dstOpts.Internal.ReplicationValidityCheck {
+                headers.Set(minIOBucketReplicationCheck, "true")
+        }
+        if !dstOpts.Internal.LegalholdTimestamp.IsZero() {
+                headers.Set(minIOBucketReplicationObjectLegalHoldTimestamp, dstOpts.Internal.LegalholdTimestamp.Format(time.RFC3339Nano))
+        }
+        if !dstOpts.Internal.RetentionTimestamp.IsZero() {
+                headers.Set(minIOBucketReplicationObjectRetentionTimestamp, dstOpts.Internal.RetentionTimestamp.Format(time.RFC3339Nano))
+        }
+        if !dstOpts.Internal.TaggingTimestamp.IsZero() {
+                headers.Set(minIOBucketReplicationTaggingTimestamp, dstOpts.Internal.TaggingTimestamp.Format(time.RFC3339Nano))
+        }
+
+        if len(dstOpts.UserTags) != 0 {
+                headers.Set(amzTaggingHeader, s3utils.TagEncode(dstOpts.UserTags))
+        }
+
+        reqMetadata := requestMetadata{
+                bucketName:   destBucket,
+                objectName:   destObject,
+                customHeader: headers,
+        }
+        if dstOpts.Internal.SourceVersionID != "" {
+                if dstOpts.Internal.SourceVersionID != nullVersionID {
+                        if _, err := uuid.Parse(dstOpts.Internal.SourceVersionID); err != nil {
+                                return ObjectInfo{}, errInvalidArgument(err.Error())
+                        }
+                }
+                urlValues := make(url.Values)
+                urlValues.Set("versionId", dstOpts.Internal.SourceVersionID)
+                reqMetadata.queryValues = urlValues
+        }
+
+        // Set the source header
+        headers.Set("x-amz-copy-source", s3utils.EncodePath(srcBucket+"/"+srcObject))
+        if srcOpts.VersionID != "" {
+                headers.Set("x-amz-copy-source", s3utils.EncodePath(srcBucket+"/"+srcObject)+"?versionId="+srcOpts.VersionID)
+        }
+        // Send upload-part-copy request
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return ObjectInfo{}, err
+        }
+
+        // Check if we got an error response.
+        if resp.StatusCode != http.StatusOK {
+                return ObjectInfo{}, httpRespToErrorResponse(resp, srcBucket, srcObject)
+        }
+
+        cpObjRes := copyObjectResult{}
+        err = xmlDecoder(resp.Body, &cpObjRes)
+        if err != nil {
+                return ObjectInfo{}, err
+        }
+
+        objInfo := ObjectInfo{
+                Key:          destObject,
+                ETag:         strings.Trim(cpObjRes.ETag, "\""),
+                LastModified: cpObjRes.LastModified,
+        }
+        return objInfo, nil
+}
+
+func (c *Client) copyObjectPartDo(ctx context.Context, srcBucket, srcObject, destBucket, destObject, uploadID string,
+        partID int, startOffset, length int64, metadata map[string]string,
+) (p CompletePart, err error) {
+        headers := make(http.Header)
+
+        // Set source
+        headers.Set("x-amz-copy-source", s3utils.EncodePath(srcBucket+"/"+srcObject))
+
+        if startOffset < 0 {
+                return p, errInvalidArgument("startOffset must be non-negative")
+        }
+
+        if length >= 0 {
+                headers.Set("x-amz-copy-source-range", fmt.Sprintf("bytes=%d-%d", startOffset, startOffset+length-1))
+        }
+
+        for k, v := range metadata {
+                headers.Set(k, v)
+        }
+
+        queryValues := make(url.Values)
+        queryValues.Set("partNumber", strconv.Itoa(partID))
+        queryValues.Set("uploadId", uploadID)
+
+        resp, err := c.executeMethod(ctx, http.MethodPut, requestMetadata{
+                bucketName:   destBucket,
+                objectName:   destObject,
+                customHeader: headers,
+                queryValues:  queryValues,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return
+        }
+
+        // Check if we got an error response.
+        if resp.StatusCode != http.StatusOK {
+                return p, httpRespToErrorResponse(resp, destBucket, destObject)
+        }
+
+        // Decode copy-part response on success.
+        cpObjRes := copyObjectResult{}
+        err = xmlDecoder(resp.Body, &cpObjRes)
+        if err != nil {
+                return p, err
+        }
+        p.PartNumber, p.ETag = partID, cpObjRes.ETag
+        return p, nil
+}
+
+// uploadPartCopy - helper function to create a part in a multipart
+// upload via an upload-part-copy request
+// https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html
+func (c *Client) uploadPartCopy(ctx context.Context, bucket, object, uploadID string, partNumber int,
+        headers http.Header,
+) (p CompletePart, err error) {
+        // Build query parameters
+        urlValues := make(url.Values)
+        urlValues.Set("partNumber", strconv.Itoa(partNumber))
+        urlValues.Set("uploadId", uploadID)
+
+        // Send upload-part-copy request
+        resp, err := c.executeMethod(ctx, http.MethodPut, requestMetadata{
+                bucketName:   bucket,
+                objectName:   object,
+                customHeader: headers,
+                queryValues:  urlValues,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return p, err
+        }
+
+        // Check if we got an error response.
+        if resp.StatusCode != http.StatusOK {
+                return p, httpRespToErrorResponse(resp, bucket, object)
+        }
+
+        // Decode copy-part response on success.
+        cpObjRes := copyObjectResult{}
+        err = xmlDecoder(resp.Body, &cpObjRes)
+        if err != nil {
+                return p, err
+        }
+        p.PartNumber, p.ETag = partNumber, cpObjRes.ETag
+        return p, nil
+}
+
+// ComposeObject - creates an object using server-side copying
+// of existing objects. It takes a list of source objects (with optional offsets)
+// and concatenates them into a new object using only server-side copying
+// operations. Optionally takes progress reader hook for applications to
+// look at current progress.
+func (c *Client) ComposeObject(ctx context.Context, dst CopyDestOptions, srcs ...CopySrcOptions) (UploadInfo, error) {
+        if len(srcs) < 1 || len(srcs) > maxPartsCount {
+                return UploadInfo{}, errInvalidArgument("There must be as least one and up to 10000 source objects.")
+        }
+
+        for _, src := range srcs {
+                if err := src.validate(); err != nil {
+                        return UploadInfo{}, err
+                }
+        }
+
+        if err := dst.validate(); err != nil {
+                return UploadInfo{}, err
+        }
+
+        srcObjectInfos := make([]ObjectInfo, len(srcs))
+        srcObjectSizes := make([]int64, len(srcs))
+        var totalSize, totalParts int64
+        var err error
+        for i, src := range srcs {
+                opts := StatObjectOptions{ServerSideEncryption: encrypt.SSE(src.Encryption), VersionID: src.VersionID}
+                srcObjectInfos[i], err = c.StatObject(context.Background(), src.Bucket, src.Object, opts)
+                if err != nil {
+                        return UploadInfo{}, err
+                }
+
+                srcCopySize := srcObjectInfos[i].Size
+                // Check if a segment is specified, and if so, is the
+                // segment within object bounds?
+                if src.MatchRange {
+                        // Since range is specified,
+                        //    0 <= src.start <= src.end
+                        // so only invalid case to check is:
+                        if src.End >= srcCopySize || src.Start < 0 {
+                                return UploadInfo{}, errInvalidArgument(
+                                        fmt.Sprintf("CopySrcOptions %d has invalid segment-to-copy [%d, %d] (size is %d)",
+                                                i, src.Start, src.End, srcCopySize))
+                        }
+                        srcCopySize = src.End - src.Start + 1
+                }
+
+                // Only the last source may be less than `absMinPartSize`
+                if srcCopySize < absMinPartSize && i < len(srcs)-1 {
+                        return UploadInfo{}, errInvalidArgument(
+                                fmt.Sprintf("CopySrcOptions %d is too small (%d) and it is not the last part", i, srcCopySize))
+                }
+
+                // Is data to copy too large?
+                totalSize += srcCopySize
+                if totalSize > maxMultipartPutObjectSize {
+                        return UploadInfo{}, errInvalidArgument(fmt.Sprintf("Cannot compose an object of size %d (> 5TiB)", totalSize))
+                }
+
+                // record source size
+                srcObjectSizes[i] = srcCopySize
+
+                // calculate parts needed for current source
+                totalParts += partsRequired(srcCopySize)
+                // Do we need more parts than we are allowed?
+                if totalParts > maxPartsCount {
+                        return UploadInfo{}, errInvalidArgument(fmt.Sprintf(
+                                "Your proposed compose object requires more than %d parts", maxPartsCount))
+                }
+        }
+
+        // Single source object case (i.e. when only one source is
+        // involved, it is being copied wholly and at most 5GiB in
+        // size, emptyfiles are also supported).
+        if (totalParts == 1 && srcs[0].Start == -1 && totalSize <= maxPartSize) || (totalSize == 0) {
+                return c.CopyObject(ctx, dst, srcs[0])
+        }
+
+        // Now, handle multipart-copy cases.
+
+        // 1. Ensure that the object has not been changed while
+        //    we are copying data.
+        for i, src := range srcs {
+                src.MatchETag = srcObjectInfos[i].ETag
+        }
+
+        // 2. Initiate a new multipart upload.
+
+        // Set user-metadata on the destination object. If no
+        // user-metadata is specified, and there is only one source,
+        // (only) then metadata from source is copied.
+        var userMeta map[string]string
+        if dst.ReplaceMetadata {
+                userMeta = dst.UserMetadata
+        } else {
+                userMeta = srcObjectInfos[0].UserMetadata
+        }
+
+        var userTags map[string]string
+        if dst.ReplaceTags {
+                userTags = dst.UserTags
+        } else {
+                userTags = srcObjectInfos[0].UserTags
+        }
+
+        uploadID, err := c.newUploadID(ctx, dst.Bucket, dst.Object, PutObjectOptions{
+                ServerSideEncryption: dst.Encryption,
+                UserMetadata:         userMeta,
+                UserTags:             userTags,
+                Mode:                 dst.Mode,
+                RetainUntilDate:      dst.RetainUntilDate,
+                LegalHold:            dst.LegalHold,
+        })
+        if err != nil {
+                return UploadInfo{}, err
+        }
+
+        // 3. Perform copy part uploads
+        objParts := []CompletePart{}
+        partIndex := 1
+        for i, src := range srcs {
+                h := make(http.Header)
+                src.Marshal(h)
+                if dst.Encryption != nil && dst.Encryption.Type() == encrypt.SSEC {
+                        dst.Encryption.Marshal(h)
+                }
+
+                // calculate start/end indices of parts after
+                // splitting.
+                startIdx, endIdx := calculateEvenSplits(srcObjectSizes[i], src)
+                for j, start := range startIdx {
+                        end := endIdx[j]
+
+                        // Add (or reset) source range header for
+                        // upload part copy request.
+                        h.Set("x-amz-copy-source-range",
+                                fmt.Sprintf("bytes=%d-%d", start, end))
+
+                        // make upload-part-copy request
+                        complPart, err := c.uploadPartCopy(ctx, dst.Bucket,
+                                dst.Object, uploadID, partIndex, h)
+                        if err != nil {
+                                return UploadInfo{}, err
+                        }
+                        if dst.Progress != nil {
+                                io.CopyN(io.Discard, dst.Progress, end-start+1)
+                        }
+                        objParts = append(objParts, complPart)
+                        partIndex++
+                }
+        }
+
+        // 4. Make final complete-multipart request.
+        uploadInfo, err := c.completeMultipartUpload(ctx, dst.Bucket, dst.Object, uploadID,
+                completeMultipartUpload{Parts: objParts}, PutObjectOptions{ServerSideEncryption: dst.Encryption})
+        if err != nil {
+                return UploadInfo{}, err
+        }
+
+        uploadInfo.Size = totalSize
+        return uploadInfo, nil
+}
+
+// partsRequired is maximum parts possible with
+// max part size of ceiling(maxMultipartPutObjectSize / (maxPartsCount - 1))
+func partsRequired(size int64) int64 {
+        maxPartSize := maxMultipartPutObjectSize / (maxPartsCount - 1)
+        r := size / int64(maxPartSize)
+        if size%int64(maxPartSize) > 0 {
+                r++
+        }
+        return r
+}
+
+// calculateEvenSplits - computes splits for a source and returns
+// start and end index slices. Splits happen evenly to be sure that no
+// part is less than 5MiB, as that could fail the multipart request if
+// it is not the last part.
+func calculateEvenSplits(size int64, src CopySrcOptions) (startIndex, endIndex []int64) {
+        if size == 0 {
+                return
+        }
+
+        reqParts := partsRequired(size)
+        startIndex = make([]int64, reqParts)
+        endIndex = make([]int64, reqParts)
+        // Compute number of required parts `k`, as:
+        //
+        // k = ceiling(size / copyPartSize)
+        //
+        // Now, distribute the `size` bytes in the source into
+        // k parts as evenly as possible:
+        //
+        // r parts sized (q+1) bytes, and
+        // (k - r) parts sized q bytes, where
+        //
+        // size = q * k + r (by simple division of size by k,
+        // so that 0 <= r < k)
+        //
+        start := src.Start
+        if start == -1 {
+                start = 0
+        }
+        quot, rem := size/reqParts, size%reqParts
+        nextStart := start
+        for j := int64(0); j < reqParts; j++ {
+                curPartSize := quot
+                if j < rem {
+                        curPartSize++
+                }
+
+                cStart := nextStart
+                cEnd := cStart + curPartSize - 1
+                nextStart = cEnd + 1
+
+                startIndex[j], endIndex[j] = cStart, cEnd
+        }
+        return
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-copy-object.go b/vendor/github.com/minio/minio-go/v7/api-copy-object.go
new file mode 100644
index 0000000..0c95d91
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-copy-object.go
@@ -0,0 +1,76 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2017, 2018 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 minio
+
+import (
+        "context"
+        "io"
+        "net/http"
+)
+
+// CopyObject - copy a source object into a new object
+func (c *Client) CopyObject(ctx context.Context, dst CopyDestOptions, src CopySrcOptions) (UploadInfo, error) {
+        if err := src.validate(); err != nil {
+                return UploadInfo{}, err
+        }
+
+        if err := dst.validate(); err != nil {
+                return UploadInfo{}, err
+        }
+
+        header := make(http.Header)
+        dst.Marshal(header)
+        src.Marshal(header)
+
+        resp, err := c.executeMethod(ctx, http.MethodPut, requestMetadata{
+                bucketName:   dst.Bucket,
+                objectName:   dst.Object,
+                customHeader: header,
+        })
+        if err != nil {
+                return UploadInfo{}, err
+        }
+        defer closeResponse(resp)
+
+        if resp.StatusCode != http.StatusOK {
+                return UploadInfo{}, httpRespToErrorResponse(resp, dst.Bucket, dst.Object)
+        }
+
+        // Update the progress properly after successful copy.
+        if dst.Progress != nil {
+                io.Copy(io.Discard, io.LimitReader(dst.Progress, dst.Size))
+        }
+
+        cpObjRes := copyObjectResult{}
+        if err = xmlDecoder(resp.Body, &cpObjRes); err != nil {
+                return UploadInfo{}, err
+        }
+
+        // extract lifecycle expiry date and rule ID
+        expTime, ruleID := amzExpirationToExpiryDateRuleID(resp.Header.Get(amzExpiration))
+
+        return UploadInfo{
+                Bucket:           dst.Bucket,
+                Key:              dst.Object,
+                LastModified:     cpObjRes.LastModified,
+                ETag:             trimEtag(resp.Header.Get("ETag")),
+                VersionID:        resp.Header.Get(amzVersionID),
+                Expiration:       expTime,
+                ExpirationRuleID: ruleID,
+        }, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-datatypes.go b/vendor/github.com/minio/minio-go/v7/api-datatypes.go
new file mode 100644
index 0000000..97a6f80
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-datatypes.go
@@ -0,0 +1,254 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2020 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 minio
+
+import (
+        "encoding/xml"
+        "io"
+        "net/http"
+        "net/url"
+        "strings"
+        "time"
+)
+
+// BucketInfo container for bucket metadata.
+type BucketInfo struct {
+        // The name of the bucket.
+        Name string `json:"name"`
+        // Date the bucket was created.
+        CreationDate time.Time `json:"creationDate"`
+}
+
+// StringMap represents map with custom UnmarshalXML
+type StringMap map[string]string
+
+// UnmarshalXML unmarshals the XML into a map of string to strings,
+// creating a key in the map for each tag and setting it's value to the
+// tags contents.
+//
+// The fact this function is on the pointer of Map is important, so that
+// if m is nil it can be initialized, which is often the case if m is
+// nested in another xml structural. This is also why the first thing done
+// on the first line is initialize it.
+func (m *StringMap) UnmarshalXML(d *xml.Decoder, _ xml.StartElement) error {
+        *m = StringMap{}
+        for {
+                // Format is <key>value</key>
+                var e struct {
+                        XMLName xml.Name
+                        Value   string `xml:",chardata"`
+                }
+                err := d.Decode(&e)
+                if err == io.EOF {
+                        break
+                }
+                if err != nil {
+                        return err
+                }
+                (*m)[e.XMLName.Local] = e.Value
+        }
+        return nil
+}
+
+// URLMap represents map with custom UnmarshalXML
+type URLMap map[string]string
+
+// UnmarshalXML unmarshals the XML into a map of string to strings,
+// creating a key in the map for each tag and setting it's value to the
+// tags contents.
+//
+// The fact this function is on the pointer of Map is important, so that
+// if m is nil it can be initialized, which is often the case if m is
+// nested in another xml structural. This is also why the first thing done
+// on the first line is initialize it.
+func (m *URLMap) UnmarshalXML(d *xml.Decoder, se xml.StartElement) error {
+        *m = URLMap{}
+        var tgs string
+        if err := d.DecodeElement(&tgs, &se); err != nil {
+                if err == io.EOF {
+                        return nil
+                }
+                return err
+        }
+        for tgs != "" {
+                var key string
+                key, tgs, _ = stringsCut(tgs, "&")
+                if key == "" {
+                        continue
+                }
+                key, value, _ := stringsCut(key, "=")
+                key, err := url.QueryUnescape(key)
+                if err != nil {
+                        return err
+                }
+
+                value, err = url.QueryUnescape(value)
+                if err != nil {
+                        return err
+                }
+                (*m)[key] = value
+        }
+        return nil
+}
+
+// stringsCut slices s around the first instance of sep,
+// returning the text before and after sep.
+// The found result reports whether sep appears in s.
+// If sep does not appear in s, cut returns s, "", false.
+func stringsCut(s, sep string) (before, after string, found bool) {
+        if i := strings.Index(s, sep); i >= 0 {
+                return s[:i], s[i+len(sep):], true
+        }
+        return s, "", false
+}
+
+// Owner name.
+type Owner struct {
+        XMLName     xml.Name `xml:"Owner" json:"owner"`
+        DisplayName string   `xml:"ID" json:"name"`
+        ID          string   `xml:"DisplayName" json:"id"`
+}
+
+// UploadInfo contains information about the
+// newly uploaded or copied object.
+type UploadInfo struct {
+        Bucket       string
+        Key          string
+        ETag         string
+        Size         int64
+        LastModified time.Time
+        Location     string
+        VersionID    string
+
+        // Lifecycle expiry-date and ruleID associated with the expiry
+        // not to be confused with `Expires` HTTP header.
+        Expiration       time.Time
+        ExpirationRuleID string
+
+        // Verified checksum values, if any.
+        // Values are base64 (standard) encoded.
+        // For multipart objects this is a checksum of the checksum of each part.
+        ChecksumCRC32  string
+        ChecksumCRC32C string
+        ChecksumSHA1   string
+        ChecksumSHA256 string
+}
+
+// RestoreInfo contains information of the restore operation of an archived object
+type RestoreInfo struct {
+        // Is the restoring operation is still ongoing
+        OngoingRestore bool
+        // When the restored copy of the archived object will be removed
+        ExpiryTime time.Time
+}
+
+// ObjectInfo container for object metadata.
+type ObjectInfo struct {
+        // An ETag is optionally set to md5sum of an object.  In case of multipart objects,
+        // ETag is of the form MD5SUM-N where MD5SUM is md5sum of all individual md5sums of
+        // each parts concatenated into one string.
+        ETag string `json:"etag"`
+
+        Key          string    `json:"name"`         // Name of the object
+        LastModified time.Time `json:"lastModified"` // Date and time the object was last modified.
+        Size         int64     `json:"size"`         // Size in bytes of the object.
+        ContentType  string    `json:"contentType"`  // A standard MIME type describing the format of the object data.
+        Expires      time.Time `json:"expires"`      // The date and time at which the object is no longer able to be cached.
+
+        // Collection of additional metadata on the object.
+        // eg: x-amz-meta-*, content-encoding etc.
+        Metadata http.Header `json:"metadata" xml:"-"`
+
+        // x-amz-meta-* headers stripped "x-amz-meta-" prefix containing the first value.
+        // Only returned by MinIO servers.
+        UserMetadata StringMap `json:"userMetadata,omitempty"`
+
+        // x-amz-tagging values in their k/v values.
+        // Only returned by MinIO servers.
+        UserTags URLMap `json:"userTags,omitempty" xml:"UserTags"`
+
+        // x-amz-tagging-count value
+        UserTagCount int
+
+        // Owner name.
+        Owner Owner
+
+        // ACL grant.
+        Grant []Grant
+
+        // The class of storage used to store the object.
+        StorageClass string `json:"storageClass"`
+
+        // Versioning related information
+        IsLatest       bool
+        IsDeleteMarker bool
+        VersionID      string `xml:"VersionId"`
+
+        // x-amz-replication-status value is either in one of the following states
+        // - COMPLETED
+        // - PENDING
+        // - FAILED
+        // - REPLICA (on the destination)
+        ReplicationStatus string `xml:"ReplicationStatus"`
+        // set to true if delete marker has backing object version on target, and eligible to replicate
+        ReplicationReady bool
+        // Lifecycle expiry-date and ruleID associated with the expiry
+        // not to be confused with `Expires` HTTP header.
+        Expiration       time.Time
+        ExpirationRuleID string
+
+        Restore *RestoreInfo
+
+        // Checksum values
+        ChecksumCRC32  string
+        ChecksumCRC32C string
+        ChecksumSHA1   string
+        ChecksumSHA256 string
+
+        Internal *struct {
+                K int // Data blocks
+                M int // Parity blocks
+        } `xml:"Internal"`
+
+        // Error
+        Err error `json:"-"`
+}
+
+// ObjectMultipartInfo container for multipart object metadata.
+type ObjectMultipartInfo struct {
+        // Date and time at which the multipart upload was initiated.
+        Initiated time.Time `type:"timestamp" timestampFormat:"iso8601"`
+
+        Initiator initiator
+        Owner     owner
+
+        // The type of storage to use for the object. Defaults to 'STANDARD'.
+        StorageClass string
+
+        // Key of the object for which the multipart upload was initiated.
+        Key string
+
+        // Size in bytes of the object.
+        Size int64
+
+        // Upload ID that identifies the multipart upload.
+        UploadID string `xml:"UploadId"`
+
+        // Error
+        Err error
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-error-response.go b/vendor/github.com/minio/minio-go/v7/api-error-response.go
new file mode 100644
index 0000000..7df211f
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-error-response.go
@@ -0,0 +1,284 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2020 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 minio
+
+import (
+        "bytes"
+        "encoding/xml"
+        "fmt"
+        "io"
+        "net/http"
+        "strings"
+)
+
+/* **** SAMPLE ERROR RESPONSE ****
+<?xml version="1.0" encoding="UTF-8"?>
+<Error>
+   <Code>AccessDenied</Code>
+   <Message>Access Denied</Message>
+   <BucketName>bucketName</BucketName>
+   <Key>objectName</Key>
+   <RequestId>F19772218238A85A</RequestId>
+   <HostId>GuWkjyviSiGHizehqpmsD1ndz5NClSP19DOT+s2mv7gXGQ8/X1lhbDGiIJEXpGFD</HostId>
+</Error>
+*/
+
+// ErrorResponse - Is the typed error returned by all API operations.
+// ErrorResponse struct should be comparable since it is compared inside
+// golang http API (https://github.com/golang/go/issues/29768)
+type ErrorResponse struct {
+        XMLName    xml.Name `xml:"Error" json:"-"`
+        Code       string
+        Message    string
+        BucketName string
+        Key        string
+        Resource   string
+        RequestID  string `xml:"RequestId"`
+        HostID     string `xml:"HostId"`
+
+        // Region where the bucket is located. This header is returned
+        // only in HEAD bucket and ListObjects response.
+        Region string
+
+        // Captures the server string returned in response header.
+        Server string
+
+        // Underlying HTTP status code for the returned error
+        StatusCode int `xml:"-" json:"-"`
+}
+
+// ToErrorResponse - Returns parsed ErrorResponse struct from body and
+// http headers.
+//
+// For example:
+//
+//      import s3 "github.com/minio/minio-go/v7"
+//      ...
+//      ...
+//      reader, stat, err := s3.GetObject(...)
+//      if err != nil {
+//         resp := s3.ToErrorResponse(err)
+//      }
+//      ...
+func ToErrorResponse(err error) ErrorResponse {
+        switch err := err.(type) {
+        case ErrorResponse:
+                return err
+        default:
+                return ErrorResponse{}
+        }
+}
+
+// Error - Returns S3 error string.
+func (e ErrorResponse) Error() string {
+        if e.Message == "" {
+                msg, ok := s3ErrorResponseMap[e.Code]
+                if !ok {
+                        msg = fmt.Sprintf("Error response code %s.", e.Code)
+                }
+                return msg
+        }
+        return e.Message
+}
+
+// Common string for errors to report issue location in unexpected
+// cases.
+const (
+        reportIssue = "Please report this issue at https://github.com/minio/minio-go/issues."
+)
+
+// xmlDecodeAndBody reads the whole body up to 1MB and
+// tries to XML decode it into v.
+// The body that was read and any error from reading or decoding is returned.
+func xmlDecodeAndBody(bodyReader io.Reader, v interface{}) ([]byte, error) {
+        // read the whole body (up to 1MB)
+        const maxBodyLength = 1 << 20
+        body, err := io.ReadAll(io.LimitReader(bodyReader, maxBodyLength))
+        if err != nil {
+                return nil, err
+        }
+        return bytes.TrimSpace(body), xmlDecoder(bytes.NewReader(body), v)
+}
+
+// httpRespToErrorResponse returns a new encoded ErrorResponse
+// structure as error.
+func httpRespToErrorResponse(resp *http.Response, bucketName, objectName string) error {
+        if resp == nil {
+                msg := "Empty http response. " + reportIssue
+                return errInvalidArgument(msg)
+        }
+
+        errResp := ErrorResponse{
+                StatusCode: resp.StatusCode,
+                Server:     resp.Header.Get("Server"),
+        }
+
+        errBody, err := xmlDecodeAndBody(resp.Body, &errResp)
+        // Xml decoding failed with no body, fall back to HTTP headers.
+        if err != nil {
+                switch resp.StatusCode {
+                case http.StatusNotFound:
+                        if objectName == "" {
+                                errResp = ErrorResponse{
+                                        StatusCode: resp.StatusCode,
+                                        Code:       "NoSuchBucket",
+                                        Message:    "The specified bucket does not exist.",
+                                        BucketName: bucketName,
+                                }
+                        } else {
+                                errResp = ErrorResponse{
+                                        StatusCode: resp.StatusCode,
+                                        Code:       "NoSuchKey",
+                                        Message:    "The specified key does not exist.",
+                                        BucketName: bucketName,
+                                        Key:        objectName,
+                                }
+                        }
+                case http.StatusForbidden:
+                        errResp = ErrorResponse{
+                                StatusCode: resp.StatusCode,
+                                Code:       "AccessDenied",
+                                Message:    "Access Denied.",
+                                BucketName: bucketName,
+                                Key:        objectName,
+                        }
+                case http.StatusConflict:
+                        errResp = ErrorResponse{
+                                StatusCode: resp.StatusCode,
+                                Code:       "Conflict",
+                                Message:    "Bucket not empty.",
+                                BucketName: bucketName,
+                        }
+                case http.StatusPreconditionFailed:
+                        errResp = ErrorResponse{
+                                StatusCode: resp.StatusCode,
+                                Code:       "PreconditionFailed",
+                                Message:    s3ErrorResponseMap["PreconditionFailed"],
+                                BucketName: bucketName,
+                                Key:        objectName,
+                        }
+                default:
+                        msg := resp.Status
+                        if len(errBody) > 0 {
+                                msg = string(errBody)
+                                if len(msg) > 1024 {
+                                        msg = msg[:1024] + "..."
+                                }
+                        }
+                        errResp = ErrorResponse{
+                                StatusCode: resp.StatusCode,
+                                Code:       resp.Status,
+                                Message:    msg,
+                                BucketName: bucketName,
+                        }
+                }
+        }
+
+        code := resp.Header.Get("x-minio-error-code")
+        if code != "" {
+                errResp.Code = code
+        }
+        desc := resp.Header.Get("x-minio-error-desc")
+        if desc != "" {
+                errResp.Message = strings.Trim(desc, `"`)
+        }
+
+        // Save hostID, requestID and region information
+        // from headers if not available through error XML.
+        if errResp.RequestID == "" {
+                errResp.RequestID = resp.Header.Get("x-amz-request-id")
+        }
+        if errResp.HostID == "" {
+                errResp.HostID = resp.Header.Get("x-amz-id-2")
+        }
+        if errResp.Region == "" {
+                errResp.Region = resp.Header.Get("x-amz-bucket-region")
+        }
+        if errResp.Code == "InvalidRegion" && errResp.Region != "" {
+                errResp.Message = fmt.Sprintf("Region does not match, expecting region ‘%s’.", errResp.Region)
+        }
+
+        return errResp
+}
+
+// errTransferAccelerationBucket - bucket name is invalid to be used with transfer acceleration.
+func errTransferAccelerationBucket(bucketName string) error {
+        return ErrorResponse{
+                StatusCode: http.StatusBadRequest,
+                Code:       "InvalidArgument",
+                Message:    "The name of the bucket used for Transfer Acceleration must be DNS-compliant and must not contain periods ‘.’.",
+                BucketName: bucketName,
+        }
+}
+
+// errEntityTooLarge - Input size is larger than supported maximum.
+func errEntityTooLarge(totalSize, maxObjectSize int64, bucketName, objectName string) error {
+        msg := fmt.Sprintf("Your proposed upload size ‘%d’ exceeds the maximum allowed object size ‘%d’ for single PUT operation.", totalSize, maxObjectSize)
+        return ErrorResponse{
+                StatusCode: http.StatusBadRequest,
+                Code:       "EntityTooLarge",
+                Message:    msg,
+                BucketName: bucketName,
+                Key:        objectName,
+        }
+}
+
+// errEntityTooSmall - Input size is smaller than supported minimum.
+func errEntityTooSmall(totalSize int64, bucketName, objectName string) error {
+        msg := fmt.Sprintf("Your proposed upload size ‘%d’ is below the minimum allowed object size ‘0B’ for single PUT operation.", totalSize)
+        return ErrorResponse{
+                StatusCode: http.StatusBadRequest,
+                Code:       "EntityTooSmall",
+                Message:    msg,
+                BucketName: bucketName,
+                Key:        objectName,
+        }
+}
+
+// errUnexpectedEOF - Unexpected end of file reached.
+func errUnexpectedEOF(totalRead, totalSize int64, bucketName, objectName string) error {
+        msg := fmt.Sprintf("Data read ‘%d’ is not equal to the size ‘%d’ of the input Reader.", totalRead, totalSize)
+        return ErrorResponse{
+                StatusCode: http.StatusBadRequest,
+                Code:       "UnexpectedEOF",
+                Message:    msg,
+                BucketName: bucketName,
+                Key:        objectName,
+        }
+}
+
+// errInvalidArgument - Invalid argument response.
+func errInvalidArgument(message string) error {
+        return ErrorResponse{
+                StatusCode: http.StatusBadRequest,
+                Code:       "InvalidArgument",
+                Message:    message,
+                RequestID:  "minio",
+        }
+}
+
+// errAPINotSupported - API not supported response
+// The specified API call is not supported
+func errAPINotSupported(message string) error {
+        return ErrorResponse{
+                StatusCode: http.StatusNotImplemented,
+                Code:       "APINotSupported",
+                Message:    message,
+                RequestID:  "minio",
+        }
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-get-object-acl.go b/vendor/github.com/minio/minio-go/v7/api-get-object-acl.go
new file mode 100644
index 0000000..9041d99
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-get-object-acl.go
@@ -0,0 +1,152 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2018 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 minio
+
+import (
+        "context"
+        "encoding/xml"
+        "net/http"
+        "net/url"
+)
+
+// Grantee represents the person being granted permissions.
+type Grantee struct {
+        XMLName     xml.Name `xml:"Grantee"`
+        ID          string   `xml:"ID"`
+        DisplayName string   `xml:"DisplayName"`
+        URI         string   `xml:"URI"`
+}
+
+// Grant holds grant information
+type Grant struct {
+        XMLName    xml.Name `xml:"Grant"`
+        Grantee    Grantee
+        Permission string `xml:"Permission"`
+}
+
+// AccessControlList contains the set of grantees and the permissions assigned to each grantee.
+type AccessControlList struct {
+        XMLName    xml.Name `xml:"AccessControlList"`
+        Grant      []Grant
+        Permission string `xml:"Permission"`
+}
+
+type accessControlPolicy struct {
+        XMLName           xml.Name `xml:"AccessControlPolicy"`
+        Owner             Owner
+        AccessControlList AccessControlList
+}
+
+// GetObjectACL get object ACLs
+func (c *Client) GetObjectACL(ctx context.Context, bucketName, objectName string) (*ObjectInfo, error) {
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName: bucketName,
+                objectName: objectName,
+                queryValues: url.Values{
+                        "acl": []string{""},
+                },
+        })
+        if err != nil {
+                return nil, err
+        }
+        defer closeResponse(resp)
+
+        if resp.StatusCode != http.StatusOK {
+                return nil, httpRespToErrorResponse(resp, bucketName, objectName)
+        }
+
+        res := &accessControlPolicy{}
+
+        if err := xmlDecoder(resp.Body, res); err != nil {
+                return nil, err
+        }
+
+        objInfo, err := c.StatObject(ctx, bucketName, objectName, StatObjectOptions{})
+        if err != nil {
+                return nil, err
+        }
+
+        objInfo.Owner.DisplayName = res.Owner.DisplayName
+        objInfo.Owner.ID = res.Owner.ID
+
+        objInfo.Grant = append(objInfo.Grant, res.AccessControlList.Grant...)
+
+        cannedACL := getCannedACL(res)
+        if cannedACL != "" {
+                objInfo.Metadata.Add("X-Amz-Acl", cannedACL)
+                return &objInfo, nil
+        }
+
+        grantACL := getAmzGrantACL(res)
+        for k, v := range grantACL {
+                objInfo.Metadata[k] = v
+        }
+
+        return &objInfo, nil
+}
+
+func getCannedACL(aCPolicy *accessControlPolicy) string {
+        grants := aCPolicy.AccessControlList.Grant
+
+        switch {
+        case len(grants) == 1:
+                if grants[0].Grantee.URI == "" && grants[0].Permission == "FULL_CONTROL" {
+                        return "private"
+                }
+        case len(grants) == 2:
+                for _, g := range grants {
+                        if g.Grantee.URI == "http://acs.amazonaws.com/groups/global/AuthenticatedUsers" && g.Permission == "READ" {
+                                return "authenticated-read"
+                        }
+                        if g.Grantee.URI == "http://acs.amazonaws.com/groups/global/AllUsers" && g.Permission == "READ" {
+                                return "public-read"
+                        }
+                        if g.Permission == "READ" && g.Grantee.ID == aCPolicy.Owner.ID {
+                                return "bucket-owner-read"
+                        }
+                }
+        case len(grants) == 3:
+                for _, g := range grants {
+                        if g.Grantee.URI == "http://acs.amazonaws.com/groups/global/AllUsers" && g.Permission == "WRITE" {
+                                return "public-read-write"
+                        }
+                }
+        }
+        return ""
+}
+
+func getAmzGrantACL(aCPolicy *accessControlPolicy) map[string][]string {
+        grants := aCPolicy.AccessControlList.Grant
+        res := map[string][]string{}
+
+        for _, g := range grants {
+                switch {
+                case g.Permission == "READ":
+                        res["X-Amz-Grant-Read"] = append(res["X-Amz-Grant-Read"], "id="+g.Grantee.ID)
+                case g.Permission == "WRITE":
+                        res["X-Amz-Grant-Write"] = append(res["X-Amz-Grant-Write"], "id="+g.Grantee.ID)
+                case g.Permission == "READ_ACP":
+                        res["X-Amz-Grant-Read-Acp"] = append(res["X-Amz-Grant-Read-Acp"], "id="+g.Grantee.ID)
+                case g.Permission == "WRITE_ACP":
+                        res["X-Amz-Grant-Write-Acp"] = append(res["X-Amz-Grant-Write-Acp"], "id="+g.Grantee.ID)
+                case g.Permission == "FULL_CONTROL":
+                        res["X-Amz-Grant-Full-Control"] = append(res["X-Amz-Grant-Full-Control"], "id="+g.Grantee.ID)
+                }
+        }
+        return res
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-get-object-file.go b/vendor/github.com/minio/minio-go/v7/api-get-object-file.go
new file mode 100644
index 0000000..2332dbf
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-get-object-file.go
@@ -0,0 +1,127 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 minio
+
+import (
+        "context"
+        "io"
+        "os"
+        "path/filepath"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// FGetObject - download contents of an object to a local file.
+// The options can be used to specify the GET request further.
+func (c *Client) FGetObject(ctx context.Context, bucketName, objectName, filePath string, opts GetObjectOptions) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return err
+        }
+
+        // Verify if destination already exists.
+        st, err := os.Stat(filePath)
+        if err == nil {
+                // If the destination exists and is a directory.
+                if st.IsDir() {
+                        return errInvalidArgument("fileName is a directory.")
+                }
+        }
+
+        // Proceed if file does not exist. return for all other errors.
+        if err != nil {
+                if !os.IsNotExist(err) {
+                        return err
+                }
+        }
+
+        // Extract top level directory.
+        objectDir, _ := filepath.Split(filePath)
+        if objectDir != "" {
+                // Create any missing top level directories.
+                if err := os.MkdirAll(objectDir, 0o700); err != nil {
+                        return err
+                }
+        }
+
+        // Gather md5sum.
+        objectStat, err := c.StatObject(ctx, bucketName, objectName, StatObjectOptions(opts))
+        if err != nil {
+                return err
+        }
+
+        // Write to a temporary file "fileName.part.minio" before saving.
+        filePartPath := filePath + objectStat.ETag + ".part.minio"
+
+        // If exists, open in append mode. If not create it as a part file.
+        filePart, err := os.OpenFile(filePartPath, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o600)
+        if err != nil {
+                return err
+        }
+
+        // If we return early with an error, be sure to close and delete
+        // filePart.  If we have an error along the way there is a chance
+        // that filePart is somehow damaged, and we should discard it.
+        closeAndRemove := true
+        defer func() {
+                if closeAndRemove {
+                        _ = filePart.Close()
+                        _ = os.Remove(filePartPath)
+                }
+        }()
+
+        // Issue Stat to get the current offset.
+        st, err = filePart.Stat()
+        if err != nil {
+                return err
+        }
+
+        // Initialize get object request headers to set the
+        // appropriate range offsets to read from.
+        if st.Size() > 0 {
+                opts.SetRange(st.Size(), 0)
+        }
+
+        // Seek to current position for incoming reader.
+        objectReader, objectStat, _, err := c.getObject(ctx, bucketName, objectName, opts)
+        if err != nil {
+                return err
+        }
+
+        // Write to the part file.
+        if _, err = io.CopyN(filePart, objectReader, objectStat.Size); err != nil {
+                return err
+        }
+
+        // Close the file before rename, this is specifically needed for Windows users.
+        closeAndRemove = false
+        if err = filePart.Close(); err != nil {
+                return err
+        }
+
+        // Safely completed. Now commit by renaming to actual filename.
+        if err = os.Rename(filePartPath, filePath); err != nil {
+                return err
+        }
+
+        // Return.
+        return nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-get-object.go b/vendor/github.com/minio/minio-go/v7/api-get-object.go
new file mode 100644
index 0000000..9e6b154
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-get-object.go
@@ -0,0 +1,683 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2020 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 minio
+
+import (
+        "context"
+        "errors"
+        "fmt"
+        "io"
+        "net/http"
+        "sync"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// GetObject wrapper function that accepts a request context
+func (c *Client) GetObject(ctx context.Context, bucketName, objectName string, opts GetObjectOptions) (*Object, error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return nil, err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return nil, err
+        }
+
+        gctx, cancel := context.WithCancel(ctx)
+
+        // Detect if snowball is server location we are talking to.
+        var snowball bool
+        if location, ok := c.bucketLocCache.Get(bucketName); ok {
+                snowball = location == "snowball"
+        }
+
+        var (
+                err        error
+                httpReader io.ReadCloser
+                objectInfo ObjectInfo
+                totalRead  int
+        )
+
+        // Create request channel.
+        reqCh := make(chan getRequest)
+        // Create response channel.
+        resCh := make(chan getResponse)
+
+        // This routine feeds partial object data as and when the caller reads.
+        go func() {
+                defer close(resCh)
+                defer func() {
+                        // Close the http response body before returning.
+                        // This ends the connection with the server.
+                        if httpReader != nil {
+                                httpReader.Close()
+                        }
+                }()
+                defer cancel()
+
+                // Used to verify if etag of object has changed since last read.
+                var etag string
+
+                for req := range reqCh {
+                        // If this is the first request we may not need to do a getObject request yet.
+                        if req.isFirstReq {
+                                // First request is a Read/ReadAt.
+                                if req.isReadOp {
+                                        // Differentiate between wanting the whole object and just a range.
+                                        if req.isReadAt {
+                                                // If this is a ReadAt request only get the specified range.
+                                                // Range is set with respect to the offset and length of the buffer requested.
+                                                // Do not set objectInfo from the first readAt request because it will not get
+                                                // the whole object.
+                                                opts.SetRange(req.Offset, req.Offset+int64(len(req.Buffer))-1)
+                                        } else if req.Offset > 0 {
+                                                opts.SetRange(req.Offset, 0)
+                                        }
+                                        httpReader, objectInfo, _, err = c.getObject(gctx, bucketName, objectName, opts)
+                                        if err != nil {
+                                                resCh <- getResponse{Error: err}
+                                                return
+                                        }
+                                        etag = objectInfo.ETag
+                                        // Read at least firstReq.Buffer bytes, if not we have
+                                        // reached our EOF.
+                                        size, err := readFull(httpReader, req.Buffer)
+                                        totalRead += size
+                                        if size > 0 && err == io.ErrUnexpectedEOF {
+                                                if int64(size) < objectInfo.Size {
+                                                        // In situations when returned size
+                                                        // is less than the expected content
+                                                        // length set by the server, make sure
+                                                        // we return io.ErrUnexpectedEOF
+                                                        err = io.ErrUnexpectedEOF
+                                                } else {
+                                                        // If an EOF happens after reading some but not
+                                                        // all the bytes ReadFull returns ErrUnexpectedEOF
+                                                        err = io.EOF
+                                                }
+                                        } else if size == 0 && err == io.EOF && objectInfo.Size > 0 {
+                                                // Special cases when server writes more data
+                                                // than the content-length, net/http response
+                                                // body returns an error, instead of converting
+                                                // it to io.EOF - return unexpected EOF.
+                                                err = io.ErrUnexpectedEOF
+                                        }
+                                        // Send back the first response.
+                                        resCh <- getResponse{
+                                                objectInfo: objectInfo,
+                                                Size:       size,
+                                                Error:      err,
+                                                didRead:    true,
+                                        }
+                                } else {
+                                        // First request is a Stat or Seek call.
+                                        // Only need to run a StatObject until an actual Read or ReadAt request comes through.
+
+                                        // Remove range header if already set, for stat Operations to get original file size.
+                                        delete(opts.headers, "Range")
+                                        objectInfo, err = c.StatObject(gctx, bucketName, objectName, StatObjectOptions(opts))
+                                        if err != nil {
+                                                resCh <- getResponse{
+                                                        Error: err,
+                                                }
+                                                // Exit the go-routine.
+                                                return
+                                        }
+                                        etag = objectInfo.ETag
+                                        // Send back the first response.
+                                        resCh <- getResponse{
+                                                objectInfo: objectInfo,
+                                        }
+                                }
+                        } else if req.settingObjectInfo { // Request is just to get objectInfo.
+                                // Remove range header if already set, for stat Operations to get original file size.
+                                delete(opts.headers, "Range")
+                                // Check whether this is snowball
+                                // if yes do not use If-Match feature
+                                // it doesn't work.
+                                if etag != "" && !snowball {
+                                        opts.SetMatchETag(etag)
+                                }
+                                objectInfo, err := c.StatObject(gctx, bucketName, objectName, StatObjectOptions(opts))
+                                if err != nil {
+                                        resCh <- getResponse{
+                                                Error: err,
+                                        }
+                                        // Exit the goroutine.
+                                        return
+                                }
+                                // Send back the objectInfo.
+                                resCh <- getResponse{
+                                        objectInfo: objectInfo,
+                                }
+                        } else {
+                                // Offset changes fetch the new object at an Offset.
+                                // Because the httpReader may not be set by the first
+                                // request if it was a stat or seek it must be checked
+                                // if the object has been read or not to only initialize
+                                // new ones when they haven't been already.
+                                // All readAt requests are new requests.
+                                if req.DidOffsetChange || !req.beenRead {
+                                        // Check whether this is snowball
+                                        // if yes do not use If-Match feature
+                                        // it doesn't work.
+                                        if etag != "" && !snowball {
+                                                opts.SetMatchETag(etag)
+                                        }
+                                        if httpReader != nil {
+                                                // Close previously opened http reader.
+                                                httpReader.Close()
+                                        }
+                                        // If this request is a readAt only get the specified range.
+                                        if req.isReadAt {
+                                                // Range is set with respect to the offset and length of the buffer requested.
+                                                opts.SetRange(req.Offset, req.Offset+int64(len(req.Buffer))-1)
+                                        } else if req.Offset > 0 { // Range is set with respect to the offset.
+                                                opts.SetRange(req.Offset, 0)
+                                        } else {
+                                                // Remove range header if already set
+                                                delete(opts.headers, "Range")
+                                        }
+                                        httpReader, objectInfo, _, err = c.getObject(gctx, bucketName, objectName, opts)
+                                        if err != nil {
+                                                resCh <- getResponse{
+                                                        Error: err,
+                                                }
+                                                return
+                                        }
+                                        totalRead = 0
+                                }
+
+                                // Read at least req.Buffer bytes, if not we have
+                                // reached our EOF.
+                                size, err := readFull(httpReader, req.Buffer)
+                                totalRead += size
+                                if size > 0 && err == io.ErrUnexpectedEOF {
+                                        if int64(totalRead) < objectInfo.Size {
+                                                // In situations when returned size
+                                                // is less than the expected content
+                                                // length set by the server, make sure
+                                                // we return io.ErrUnexpectedEOF
+                                                err = io.ErrUnexpectedEOF
+                                        } else {
+                                                // If an EOF happens after reading some but not
+                                                // all the bytes ReadFull returns ErrUnexpectedEOF
+                                                err = io.EOF
+                                        }
+                                } else if size == 0 && err == io.EOF && objectInfo.Size > 0 {
+                                        // Special cases when server writes more data
+                                        // than the content-length, net/http response
+                                        // body returns an error, instead of converting
+                                        // it to io.EOF - return unexpected EOF.
+                                        err = io.ErrUnexpectedEOF
+                                }
+
+                                // Reply back how much was read.
+                                resCh <- getResponse{
+                                        Size:       size,
+                                        Error:      err,
+                                        didRead:    true,
+                                        objectInfo: objectInfo,
+                                }
+                        }
+                }
+        }()
+
+        // Create a newObject through the information sent back by reqCh.
+        return newObject(gctx, cancel, reqCh, resCh), nil
+}
+
+// get request message container to communicate with internal
+// go-routine.
+type getRequest struct {
+        Buffer            []byte
+        Offset            int64 // readAt offset.
+        DidOffsetChange   bool  // Tracks the offset changes for Seek requests.
+        beenRead          bool  // Determines if this is the first time an object is being read.
+        isReadAt          bool  // Determines if this request is a request to a specific range
+        isReadOp          bool  // Determines if this request is a Read or Read/At request.
+        isFirstReq        bool  // Determines if this request is the first time an object is being accessed.
+        settingObjectInfo bool  // Determines if this request is to set the objectInfo of an object.
+}
+
+// get response message container to reply back for the request.
+type getResponse struct {
+        Size       int
+        Error      error
+        didRead    bool       // Lets subsequent calls know whether or not httpReader has been initiated.
+        objectInfo ObjectInfo // Used for the first request.
+}
+
+// Object represents an open object. It implements
+// Reader, ReaderAt, Seeker, Closer for a HTTP stream.
+type Object struct {
+        // Mutex.
+        mutex *sync.Mutex
+
+        // User allocated and defined.
+        reqCh      chan<- getRequest
+        resCh      <-chan getResponse
+        ctx        context.Context
+        cancel     context.CancelFunc
+        currOffset int64
+        objectInfo ObjectInfo
+
+        // Ask lower level to initiate data fetching based on currOffset
+        seekData bool
+
+        // Keeps track of closed call.
+        isClosed bool
+
+        // Keeps track of if this is the first call.
+        isStarted bool
+
+        // Previous error saved for future calls.
+        prevErr error
+
+        // Keeps track of if this object has been read yet.
+        beenRead bool
+
+        // Keeps track of if objectInfo has been set yet.
+        objectInfoSet bool
+}
+
+// doGetRequest - sends and blocks on the firstReqCh and reqCh of an object.
+// Returns back the size of the buffer read, if anything was read, as well
+// as any error encountered. For all first requests sent on the object
+// it is also responsible for sending back the objectInfo.
+func (o *Object) doGetRequest(request getRequest) (getResponse, error) {
+        select {
+        case <-o.ctx.Done():
+                return getResponse{}, o.ctx.Err()
+        case o.reqCh <- request:
+        }
+
+        response := <-o.resCh
+
+        // Return any error to the top level.
+        if response.Error != nil {
+                return response, response.Error
+        }
+
+        // This was the first request.
+        if !o.isStarted {
+                // The object has been operated on.
+                o.isStarted = true
+        }
+        // Set the objectInfo if the request was not readAt
+        // and it hasn't been set before.
+        if !o.objectInfoSet && !request.isReadAt {
+                o.objectInfo = response.objectInfo
+                o.objectInfoSet = true
+        }
+        // Set beenRead only if it has not been set before.
+        if !o.beenRead {
+                o.beenRead = response.didRead
+        }
+        // Data are ready on the wire, no need to reinitiate connection in lower level
+        o.seekData = false
+
+        return response, nil
+}
+
+// setOffset - handles the setting of offsets for
+// Read/ReadAt/Seek requests.
+func (o *Object) setOffset(bytesRead int64) error {
+        // Update the currentOffset.
+        o.currOffset += bytesRead
+
+        if o.objectInfo.Size > -1 && o.currOffset >= o.objectInfo.Size {
+                return io.EOF
+        }
+        return nil
+}
+
+// Read reads up to len(b) bytes into b. It returns the number of
+// bytes read (0 <= n <= len(b)) and any error encountered. Returns
+// io.EOF upon end of file.
+func (o *Object) Read(b []byte) (n int, err error) {
+        if o == nil {
+                return 0, errInvalidArgument("Object is nil")
+        }
+
+        // Locking.
+        o.mutex.Lock()
+        defer o.mutex.Unlock()
+
+        // prevErr is previous error saved from previous operation.
+        if o.prevErr != nil || o.isClosed {
+                return 0, o.prevErr
+        }
+
+        // Create a new request.
+        readReq := getRequest{
+                isReadOp: true,
+                beenRead: o.beenRead,
+                Buffer:   b,
+        }
+
+        // Alert that this is the first request.
+        if !o.isStarted {
+                readReq.isFirstReq = true
+        }
+
+        // Ask to establish a new data fetch routine based on seekData flag
+        readReq.DidOffsetChange = o.seekData
+        readReq.Offset = o.currOffset
+
+        // Send and receive from the first request.
+        response, err := o.doGetRequest(readReq)
+        if err != nil && err != io.EOF {
+                // Save the error for future calls.
+                o.prevErr = err
+                return response.Size, err
+        }
+
+        // Bytes read.
+        bytesRead := int64(response.Size)
+
+        // Set the new offset.
+        oerr := o.setOffset(bytesRead)
+        if oerr != nil {
+                // Save the error for future calls.
+                o.prevErr = oerr
+                return response.Size, oerr
+        }
+
+        // Return the response.
+        return response.Size, err
+}
+
+// Stat returns the ObjectInfo structure describing Object.
+func (o *Object) Stat() (ObjectInfo, error) {
+        if o == nil {
+                return ObjectInfo{}, errInvalidArgument("Object is nil")
+        }
+        // Locking.
+        o.mutex.Lock()
+        defer o.mutex.Unlock()
+
+        if o.prevErr != nil && o.prevErr != io.EOF || o.isClosed {
+                return ObjectInfo{}, o.prevErr
+        }
+
+        // This is the first request.
+        if !o.isStarted || !o.objectInfoSet {
+                // Send the request and get the response.
+                _, err := o.doGetRequest(getRequest{
+                        isFirstReq:        !o.isStarted,
+                        settingObjectInfo: !o.objectInfoSet,
+                })
+                if err != nil {
+                        o.prevErr = err
+                        return ObjectInfo{}, err
+                }
+        }
+
+        return o.objectInfo, nil
+}
+
+// ReadAt reads len(b) bytes from the File starting at byte offset
+// off. It returns the number of bytes read and the error, if any.
+// ReadAt always returns a non-nil error when n < len(b). At end of
+// file, that error is io.EOF.
+func (o *Object) ReadAt(b []byte, offset int64) (n int, err error) {
+        if o == nil {
+                return 0, errInvalidArgument("Object is nil")
+        }
+
+        // Locking.
+        o.mutex.Lock()
+        defer o.mutex.Unlock()
+
+        // prevErr is error which was saved in previous operation.
+        if o.prevErr != nil && o.prevErr != io.EOF || o.isClosed {
+                return 0, o.prevErr
+        }
+
+        // Set the current offset to ReadAt offset, because the current offset will be shifted at the end of this method.
+        o.currOffset = offset
+
+        // Can only compare offsets to size when size has been set.
+        if o.objectInfoSet {
+                // If offset is negative than we return io.EOF.
+                // If offset is greater than or equal to object size we return io.EOF.
+                if (o.objectInfo.Size > -1 && offset >= o.objectInfo.Size) || offset < 0 {
+                        return 0, io.EOF
+                }
+        }
+
+        // Create the new readAt request.
+        readAtReq := getRequest{
+                isReadOp:        true,
+                isReadAt:        true,
+                DidOffsetChange: true,       // Offset always changes.
+                beenRead:        o.beenRead, // Set if this is the first request to try and read.
+                Offset:          offset,     // Set the offset.
+                Buffer:          b,
+        }
+
+        // Alert that this is the first request.
+        if !o.isStarted {
+                readAtReq.isFirstReq = true
+        }
+
+        // Send and receive from the first request.
+        response, err := o.doGetRequest(readAtReq)
+        if err != nil && err != io.EOF {
+                // Save the error.
+                o.prevErr = err
+                return response.Size, err
+        }
+        // Bytes read.
+        bytesRead := int64(response.Size)
+        // There is no valid objectInfo yet
+        //      to compare against for EOF.
+        if !o.objectInfoSet {
+                // Update the currentOffset.
+                o.currOffset += bytesRead
+        } else {
+                // If this was not the first request update
+                // the offsets and compare against objectInfo
+                // for EOF.
+                oerr := o.setOffset(bytesRead)
+                if oerr != nil {
+                        o.prevErr = oerr
+                        return response.Size, oerr
+                }
+        }
+        return response.Size, err
+}
+
+// Seek sets the offset for the next Read or Write to offset,
+// interpreted according to whence: 0 means relative to the
+// origin of the file, 1 means relative to the current offset,
+// and 2 means relative to the end.
+// Seek returns the new offset and an error, if any.
+//
+// Seeking to a negative offset is an error. Seeking to any positive
+// offset is legal, subsequent io operations succeed until the
+// underlying object is not closed.
+func (o *Object) Seek(offset int64, whence int) (n int64, err error) {
+        if o == nil {
+                return 0, errInvalidArgument("Object is nil")
+        }
+
+        // Locking.
+        o.mutex.Lock()
+        defer o.mutex.Unlock()
+
+        // At EOF seeking is legal allow only io.EOF, for any other errors we return.
+        if o.prevErr != nil && o.prevErr != io.EOF {
+                return 0, o.prevErr
+        }
+
+        // Negative offset is valid for whence of '2'.
+        if offset < 0 && whence != 2 {
+                return 0, errInvalidArgument(fmt.Sprintf("Negative position not allowed for %d", whence))
+        }
+
+        // This is the first request. So before anything else
+        // get the ObjectInfo.
+        if !o.isStarted || !o.objectInfoSet {
+                // Create the new Seek request.
+                seekReq := getRequest{
+                        isReadOp:   false,
+                        Offset:     offset,
+                        isFirstReq: true,
+                }
+                // Send and receive from the seek request.
+                _, err := o.doGetRequest(seekReq)
+                if err != nil {
+                        // Save the error.
+                        o.prevErr = err
+                        return 0, err
+                }
+        }
+
+        newOffset := o.currOffset
+
+        // Switch through whence.
+        switch whence {
+        default:
+                return 0, errInvalidArgument(fmt.Sprintf("Invalid whence %d", whence))
+        case 0:
+                if o.objectInfo.Size > -1 && offset > o.objectInfo.Size {
+                        return 0, io.EOF
+                }
+                newOffset = offset
+        case 1:
+                if o.objectInfo.Size > -1 && o.currOffset+offset > o.objectInfo.Size {
+                        return 0, io.EOF
+                }
+                newOffset += offset
+        case 2:
+                // If we don't know the object size return an error for io.SeekEnd
+                if o.objectInfo.Size < 0 {
+                        return 0, errInvalidArgument("Whence END is not supported when the object size is unknown")
+                }
+                // Seeking to positive offset is valid for whence '2', but
+                // since we are backing a Reader we have reached 'EOF' if
+                // offset is positive.
+                if offset > 0 {
+                        return 0, io.EOF
+                }
+                // Seeking to negative position not allowed for whence.
+                if o.objectInfo.Size+offset < 0 {
+                        return 0, errInvalidArgument(fmt.Sprintf("Seeking at negative offset not allowed for %d", whence))
+                }
+                newOffset = o.objectInfo.Size + offset
+        }
+        // Reset the saved error since we successfully seeked, let the Read
+        // and ReadAt decide.
+        if o.prevErr == io.EOF {
+                o.prevErr = nil
+        }
+
+        // Ask lower level to fetch again from source when necessary
+        o.seekData = (newOffset != o.currOffset) || o.seekData
+        o.currOffset = newOffset
+
+        // Return the effective offset.
+        return o.currOffset, nil
+}
+
+// Close - The behavior of Close after the first call returns error
+// for subsequent Close() calls.
+func (o *Object) Close() (err error) {
+        if o == nil {
+                return errInvalidArgument("Object is nil")
+        }
+
+        // Locking.
+        o.mutex.Lock()
+        defer o.mutex.Unlock()
+
+        // if already closed return an error.
+        if o.isClosed {
+                return o.prevErr
+        }
+
+        // Close successfully.
+        o.cancel()
+
+        // Close the request channel to indicate the internal go-routine to exit.
+        close(o.reqCh)
+
+        // Save for future operations.
+        errMsg := "Object is already closed. Bad file descriptor."
+        o.prevErr = errors.New(errMsg)
+        // Save here that we closed done channel successfully.
+        o.isClosed = true
+        return nil
+}
+
+// newObject instantiates a new *minio.Object*
+// ObjectInfo will be set by setObjectInfo
+func newObject(ctx context.Context, cancel context.CancelFunc, reqCh chan<- getRequest, resCh <-chan getResponse) *Object {
+        return &Object{
+                ctx:    ctx,
+                cancel: cancel,
+                mutex:  &sync.Mutex{},
+                reqCh:  reqCh,
+                resCh:  resCh,
+        }
+}
+
+// getObject - retrieve object from Object Storage.
+//
+// Additionally this function also takes range arguments to download the specified
+// range bytes of an object. Setting offset and length = 0 will download the full object.
+//
+// For more information about the HTTP Range header.
+// go to http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.
+func (c *Client) getObject(ctx context.Context, bucketName, objectName string, opts GetObjectOptions) (io.ReadCloser, ObjectInfo, http.Header, error) {
+        // Validate input arguments.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return nil, ObjectInfo{}, nil, err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return nil, ObjectInfo{}, nil, err
+        }
+
+        // Execute GET on objectName.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:       bucketName,
+                objectName:       objectName,
+                queryValues:      opts.toQueryValues(),
+                customHeader:     opts.Header(),
+                contentSHA256Hex: emptySHA256Hex,
+        })
+        if err != nil {
+                return nil, ObjectInfo{}, nil, err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusPartialContent {
+                        return nil, ObjectInfo{}, nil, httpRespToErrorResponse(resp, bucketName, objectName)
+                }
+        }
+
+        objectStat, err := ToObjectInfo(bucketName, objectName, resp.Header)
+        if err != nil {
+                closeResponse(resp)
+                return nil, ObjectInfo{}, nil, err
+        }
+
+        // do not close body here, caller will close
+        return resp.Body, objectStat, resp.Header, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-get-options.go b/vendor/github.com/minio/minio-go/v7/api-get-options.go
new file mode 100644
index 0000000..a0216e2
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-get-options.go
@@ -0,0 +1,203 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2020 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 minio
+
+import (
+        "fmt"
+        "net/http"
+        "net/url"
+        "strconv"
+        "time"
+
+        "github.com/minio/minio-go/v7/pkg/encrypt"
+)
+
+// AdvancedGetOptions for internal use by MinIO server - not intended for client use.
+type AdvancedGetOptions struct {
+        ReplicationDeleteMarker           bool
+        IsReplicationReadyForDeleteMarker bool
+        ReplicationProxyRequest           string
+}
+
+// GetObjectOptions are used to specify additional headers or options
+// during GET requests.
+type GetObjectOptions struct {
+        headers              map[string]string
+        reqParams            url.Values
+        ServerSideEncryption encrypt.ServerSide
+        VersionID            string
+        PartNumber           int
+
+        // Include any checksums, if object was uploaded with checksum.
+        // For multipart objects this is a checksum of part checksums.
+        // https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html
+        Checksum bool
+
+        // To be not used by external applications
+        Internal AdvancedGetOptions
+}
+
+// StatObjectOptions are used to specify additional headers or options
+// during GET info/stat requests.
+type StatObjectOptions = GetObjectOptions
+
+// Header returns the http.Header representation of the GET options.
+func (o GetObjectOptions) Header() http.Header {
+        headers := make(http.Header, len(o.headers))
+        for k, v := range o.headers {
+                headers.Set(k, v)
+        }
+        if o.ServerSideEncryption != nil && o.ServerSideEncryption.Type() == encrypt.SSEC {
+                o.ServerSideEncryption.Marshal(headers)
+        }
+        // this header is set for active-active replication scenario where GET/HEAD
+        // to site A is proxy'd to site B if object/version missing on site A.
+        if o.Internal.ReplicationProxyRequest != "" {
+                headers.Set(minIOBucketReplicationProxyRequest, o.Internal.ReplicationProxyRequest)
+        }
+        if o.Checksum {
+                headers.Set("x-amz-checksum-mode", "ENABLED")
+        }
+        return headers
+}
+
+// Set adds a key value pair to the options. The
+// key-value pair will be part of the HTTP GET request
+// headers.
+func (o *GetObjectOptions) Set(key, value string) {
+        if o.headers == nil {
+                o.headers = make(map[string]string)
+        }
+        o.headers[http.CanonicalHeaderKey(key)] = value
+}
+
+// SetReqParam - set request query string parameter
+// supported key: see supportedQueryValues and allowedCustomQueryPrefix.
+// If an unsupported key is passed in, it will be ignored and nothing will be done.
+func (o *GetObjectOptions) SetReqParam(key, value string) {
+        if !isCustomQueryValue(key) && !isStandardQueryValue(key) {
+                // do nothing
+                return
+        }
+        if o.reqParams == nil {
+                o.reqParams = make(url.Values)
+        }
+        o.reqParams.Set(key, value)
+}
+
+// AddReqParam - add request query string parameter
+// supported key: see supportedQueryValues and allowedCustomQueryPrefix.
+// If an unsupported key is passed in, it will be ignored and nothing will be done.
+func (o *GetObjectOptions) AddReqParam(key, value string) {
+        if !isCustomQueryValue(key) && !isStandardQueryValue(key) {
+                // do nothing
+                return
+        }
+        if o.reqParams == nil {
+                o.reqParams = make(url.Values)
+        }
+        o.reqParams.Add(key, value)
+}
+
+// SetMatchETag - set match etag.
+func (o *GetObjectOptions) SetMatchETag(etag string) error {
+        if etag == "" {
+                return errInvalidArgument("ETag cannot be empty.")
+        }
+        o.Set("If-Match", "\""+etag+"\"")
+        return nil
+}
+
+// SetMatchETagExcept - set match etag except.
+func (o *GetObjectOptions) SetMatchETagExcept(etag string) error {
+        if etag == "" {
+                return errInvalidArgument("ETag cannot be empty.")
+        }
+        o.Set("If-None-Match", "\""+etag+"\"")
+        return nil
+}
+
+// SetUnmodified - set unmodified time since.
+func (o *GetObjectOptions) SetUnmodified(modTime time.Time) error {
+        if modTime.IsZero() {
+                return errInvalidArgument("Modified since cannot be empty.")
+        }
+        o.Set("If-Unmodified-Since", modTime.Format(http.TimeFormat))
+        return nil
+}
+
+// SetModified - set modified time since.
+func (o *GetObjectOptions) SetModified(modTime time.Time) error {
+        if modTime.IsZero() {
+                return errInvalidArgument("Modified since cannot be empty.")
+        }
+        o.Set("If-Modified-Since", modTime.Format(http.TimeFormat))
+        return nil
+}
+
+// SetRange - set the start and end offset of the object to be read.
+// See https://tools.ietf.org/html/rfc7233#section-3.1 for reference.
+func (o *GetObjectOptions) SetRange(start, end int64) error {
+        switch {
+        case start == 0 && end < 0:
+                // Read last '-end' bytes. `bytes=-N`.
+                o.Set("Range", fmt.Sprintf("bytes=%d", end))
+        case 0 < start && end == 0:
+                // Read everything starting from offset
+                // 'start'. `bytes=N-`.
+                o.Set("Range", fmt.Sprintf("bytes=%d-", start))
+        case 0 <= start && start <= end:
+                // Read everything starting at 'start' till the
+                // 'end'. `bytes=N-M`
+                o.Set("Range", fmt.Sprintf("bytes=%d-%d", start, end))
+        default:
+                // All other cases such as
+                // bytes=-3-
+                // bytes=5-3
+                // bytes=-2-4
+                // bytes=-3-0
+                // bytes=-3--2
+                // are invalid.
+                return errInvalidArgument(
+                        fmt.Sprintf(
+                                "Invalid range specified: start=%d end=%d",
+                                start, end))
+        }
+        return nil
+}
+
+// toQueryValues - Convert the versionId, partNumber, and reqParams in Options to query string parameters.
+func (o *GetObjectOptions) toQueryValues() url.Values {
+        urlValues := make(url.Values)
+        if o.VersionID != "" {
+                urlValues.Set("versionId", o.VersionID)
+        }
+        if o.PartNumber > 0 {
+                urlValues.Set("partNumber", strconv.Itoa(o.PartNumber))
+        }
+
+        if o.reqParams != nil {
+                for key, values := range o.reqParams {
+                        for _, value := range values {
+                                urlValues.Add(key, value)
+                        }
+                }
+        }
+
+        return urlValues
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-list.go b/vendor/github.com/minio/minio-go/v7/api-list.go
new file mode 100644
index 0000000..31b6edf
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-list.go
@@ -0,0 +1,1057 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2020 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 minio
+
+import (
+        "context"
+        "fmt"
+        "net/http"
+        "net/url"
+        "time"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// ListBuckets list all buckets owned by this authenticated user.
+//
+// This call requires explicit authentication, no anonymous requests are
+// allowed for listing buckets.
+//
+//      api := client.New(....)
+//      for message := range api.ListBuckets(context.Background()) {
+//          fmt.Println(message)
+//      }
+func (c *Client) ListBuckets(ctx context.Context) ([]BucketInfo, error) {
+        // Execute GET on service.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{contentSHA256Hex: emptySHA256Hex})
+        defer closeResponse(resp)
+        if err != nil {
+                return nil, err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return nil, httpRespToErrorResponse(resp, "", "")
+                }
+        }
+        listAllMyBucketsResult := listAllMyBucketsResult{}
+        err = xmlDecoder(resp.Body, &listAllMyBucketsResult)
+        if err != nil {
+                return nil, err
+        }
+        return listAllMyBucketsResult.Buckets.Bucket, nil
+}
+
+// Bucket List Operations.
+func (c *Client) listObjectsV2(ctx context.Context, bucketName string, opts ListObjectsOptions) <-chan ObjectInfo {
+        // Allocate new list objects channel.
+        objectStatCh := make(chan ObjectInfo, 1)
+        // Default listing is delimited at "/"
+        delimiter := "/"
+        if opts.Recursive {
+                // If recursive we do not delimit.
+                delimiter = ""
+        }
+
+        // Return object owner information by default
+        fetchOwner := true
+
+        sendObjectInfo := func(info ObjectInfo) {
+                select {
+                case objectStatCh <- info:
+                case <-ctx.Done():
+                }
+        }
+
+        // Validate bucket name.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                defer close(objectStatCh)
+                sendObjectInfo(ObjectInfo{
+                        Err: err,
+                })
+                return objectStatCh
+        }
+
+        // Validate incoming object prefix.
+        if err := s3utils.CheckValidObjectNamePrefix(opts.Prefix); err != nil {
+                defer close(objectStatCh)
+                sendObjectInfo(ObjectInfo{
+                        Err: err,
+                })
+                return objectStatCh
+        }
+
+        // Initiate list objects goroutine here.
+        go func(objectStatCh chan<- ObjectInfo) {
+                defer func() {
+                        if contextCanceled(ctx) {
+                                objectStatCh <- ObjectInfo{
+                                        Err: ctx.Err(),
+                                }
+                        }
+                        close(objectStatCh)
+                }()
+
+                // Save continuationToken for next request.
+                var continuationToken string
+                for {
+                        // Get list of objects a maximum of 1000 per request.
+                        result, err := c.listObjectsV2Query(ctx, bucketName, opts.Prefix, continuationToken,
+                                fetchOwner, opts.WithMetadata, delimiter, opts.StartAfter, opts.MaxKeys, opts.headers)
+                        if err != nil {
+                                sendObjectInfo(ObjectInfo{
+                                        Err: err,
+                                })
+                                return
+                        }
+
+                        // If contents are available loop through and send over channel.
+                        for _, object := range result.Contents {
+                                object.ETag = trimEtag(object.ETag)
+                                select {
+                                // Send object content.
+                                case objectStatCh <- object:
+                                // If receives done from the caller, return here.
+                                case <-ctx.Done():
+                                        return
+                                }
+                        }
+
+                        // Send all common prefixes if any.
+                        // NOTE: prefixes are only present if the request is delimited.
+                        for _, obj := range result.CommonPrefixes {
+                                select {
+                                // Send object prefixes.
+                                case objectStatCh <- ObjectInfo{Key: obj.Prefix}:
+                                // If receives done from the caller, return here.
+                                case <-ctx.Done():
+                                        return
+                                }
+                        }
+
+                        // If continuation token present, save it for next request.
+                        if result.NextContinuationToken != "" {
+                                continuationToken = result.NextContinuationToken
+                        }
+
+                        // Listing ends result is not truncated, return right here.
+                        if !result.IsTruncated {
+                                return
+                        }
+
+                        // Add this to catch broken S3 API implementations.
+                        if continuationToken == "" {
+                                sendObjectInfo(ObjectInfo{
+                                        Err: fmt.Errorf("listObjectsV2 is truncated without continuationToken, %s S3 server is incompatible with S3 API", c.endpointURL),
+                                })
+                                return
+                        }
+                }
+        }(objectStatCh)
+        return objectStatCh
+}
+
+// listObjectsV2Query - (List Objects V2) - List some or all (up to 1000) of the objects in a bucket.
+//
+// You can use the request parameters as selection criteria to return a subset of the objects in a bucket.
+// request parameters :-
+// ---------
+// ?prefix - Limits the response to keys that begin with the specified prefix.
+// ?continuation-token - Used to continue iterating over a set of objects
+// ?metadata - Specifies if we want metadata for the objects as part of list operation.
+// ?delimiter - A delimiter is a character you use to group keys.
+// ?start-after - Sets a marker to start listing lexically at this key onwards.
+// ?max-keys - Sets the maximum number of keys returned in the response body.
+func (c *Client) listObjectsV2Query(ctx context.Context, bucketName, objectPrefix, continuationToken string, fetchOwner, metadata bool, delimiter, startAfter string, maxkeys int, headers http.Header) (ListBucketV2Result, error) {
+        // Validate bucket name.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return ListBucketV2Result{}, err
+        }
+        // Validate object prefix.
+        if err := s3utils.CheckValidObjectNamePrefix(objectPrefix); err != nil {
+                return ListBucketV2Result{}, err
+        }
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+
+        // Always set list-type in ListObjects V2
+        urlValues.Set("list-type", "2")
+
+        if metadata {
+                urlValues.Set("metadata", "true")
+        }
+
+        // Set this conditionally if asked
+        if startAfter != "" {
+                urlValues.Set("start-after", startAfter)
+        }
+
+        // Always set encoding-type in ListObjects V2
+        urlValues.Set("encoding-type", "url")
+
+        // Set object prefix, prefix value to be set to empty is okay.
+        urlValues.Set("prefix", objectPrefix)
+
+        // Set delimiter, delimiter value to be set to empty is okay.
+        urlValues.Set("delimiter", delimiter)
+
+        // Set continuation token
+        if continuationToken != "" {
+                urlValues.Set("continuation-token", continuationToken)
+        }
+
+        // Fetch owner when listing
+        if fetchOwner {
+                urlValues.Set("fetch-owner", "true")
+        }
+
+        // Set max keys.
+        if maxkeys > 0 {
+                urlValues.Set("max-keys", fmt.Sprintf("%d", maxkeys))
+        }
+
+        // Execute GET on bucket to list objects.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+                customHeader:     headers,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return ListBucketV2Result{}, err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return ListBucketV2Result{}, httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+
+        // Decode listBuckets XML.
+        listBucketResult := ListBucketV2Result{}
+        if err = xmlDecoder(resp.Body, &listBucketResult); err != nil {
+                return listBucketResult, err
+        }
+
+        // This is an additional verification check to make
+        // sure proper responses are received.
+        if listBucketResult.IsTruncated && listBucketResult.NextContinuationToken == "" {
+                return listBucketResult, ErrorResponse{
+                        Code:    "NotImplemented",
+                        Message: "Truncated response should have continuation token set",
+                }
+        }
+
+        for i, obj := range listBucketResult.Contents {
+                listBucketResult.Contents[i].Key, err = decodeS3Name(obj.Key, listBucketResult.EncodingType)
+                if err != nil {
+                        return listBucketResult, err
+                }
+                listBucketResult.Contents[i].LastModified = listBucketResult.Contents[i].LastModified.Truncate(time.Millisecond)
+        }
+
+        for i, obj := range listBucketResult.CommonPrefixes {
+                listBucketResult.CommonPrefixes[i].Prefix, err = decodeS3Name(obj.Prefix, listBucketResult.EncodingType)
+                if err != nil {
+                        return listBucketResult, err
+                }
+        }
+
+        // Success.
+        return listBucketResult, nil
+}
+
+func (c *Client) listObjects(ctx context.Context, bucketName string, opts ListObjectsOptions) <-chan ObjectInfo {
+        // Allocate new list objects channel.
+        objectStatCh := make(chan ObjectInfo, 1)
+        // Default listing is delimited at "/"
+        delimiter := "/"
+        if opts.Recursive {
+                // If recursive we do not delimit.
+                delimiter = ""
+        }
+
+        sendObjectInfo := func(info ObjectInfo) {
+                select {
+                case objectStatCh <- info:
+                case <-ctx.Done():
+                }
+        }
+
+        // Validate bucket name.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                defer close(objectStatCh)
+                sendObjectInfo(ObjectInfo{
+                        Err: err,
+                })
+                return objectStatCh
+        }
+        // Validate incoming object prefix.
+        if err := s3utils.CheckValidObjectNamePrefix(opts.Prefix); err != nil {
+                defer close(objectStatCh)
+                sendObjectInfo(ObjectInfo{
+                        Err: err,
+                })
+                return objectStatCh
+        }
+
+        // Initiate list objects goroutine here.
+        go func(objectStatCh chan<- ObjectInfo) {
+                defer func() {
+                        if contextCanceled(ctx) {
+                                objectStatCh <- ObjectInfo{
+                                        Err: ctx.Err(),
+                                }
+                        }
+                        close(objectStatCh)
+                }()
+
+                marker := opts.StartAfter
+                for {
+                        // Get list of objects a maximum of 1000 per request.
+                        result, err := c.listObjectsQuery(ctx, bucketName, opts.Prefix, marker, delimiter, opts.MaxKeys, opts.headers)
+                        if err != nil {
+                                sendObjectInfo(ObjectInfo{
+                                        Err: err,
+                                })
+                                return
+                        }
+
+                        // If contents are available loop through and send over channel.
+                        for _, object := range result.Contents {
+                                // Save the marker.
+                                marker = object.Key
+                                object.ETag = trimEtag(object.ETag)
+                                select {
+                                // Send object content.
+                                case objectStatCh <- object:
+                                // If receives done from the caller, return here.
+                                case <-ctx.Done():
+                                        return
+                                }
+                        }
+
+                        // Send all common prefixes if any.
+                        // NOTE: prefixes are only present if the request is delimited.
+                        for _, obj := range result.CommonPrefixes {
+                                select {
+                                // Send object prefixes.
+                                case objectStatCh <- ObjectInfo{Key: obj.Prefix}:
+                                // If receives done from the caller, return here.
+                                case <-ctx.Done():
+                                        return
+                                }
+                        }
+
+                        // If next marker present, save it for next request.
+                        if result.NextMarker != "" {
+                                marker = result.NextMarker
+                        }
+
+                        // Listing ends result is not truncated, return right here.
+                        if !result.IsTruncated {
+                                return
+                        }
+                }
+        }(objectStatCh)
+        return objectStatCh
+}
+
+func (c *Client) listObjectVersions(ctx context.Context, bucketName string, opts ListObjectsOptions) <-chan ObjectInfo {
+        // Allocate new list objects channel.
+        resultCh := make(chan ObjectInfo, 1)
+        // Default listing is delimited at "/"
+        delimiter := "/"
+        if opts.Recursive {
+                // If recursive we do not delimit.
+                delimiter = ""
+        }
+
+        sendObjectInfo := func(info ObjectInfo) {
+                select {
+                case resultCh <- info:
+                case <-ctx.Done():
+                }
+        }
+
+        // Validate bucket name.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                defer close(resultCh)
+                sendObjectInfo(ObjectInfo{
+                        Err: err,
+                })
+                return resultCh
+        }
+
+        // Validate incoming object prefix.
+        if err := s3utils.CheckValidObjectNamePrefix(opts.Prefix); err != nil {
+                defer close(resultCh)
+                sendObjectInfo(ObjectInfo{
+                        Err: err,
+                })
+                return resultCh
+        }
+
+        // Initiate list objects goroutine here.
+        go func(resultCh chan<- ObjectInfo) {
+                defer func() {
+                        if contextCanceled(ctx) {
+                                resultCh <- ObjectInfo{
+                                        Err: ctx.Err(),
+                                }
+                        }
+                        close(resultCh)
+                }()
+
+                var (
+                        keyMarker       = ""
+                        versionIDMarker = ""
+                )
+
+                for {
+                        // Get list of objects a maximum of 1000 per request.
+                        result, err := c.listObjectVersionsQuery(ctx, bucketName, opts, keyMarker, versionIDMarker, delimiter)
+                        if err != nil {
+                                sendObjectInfo(ObjectInfo{
+                                        Err: err,
+                                })
+                                return
+                        }
+
+                        // If contents are available loop through and send over channel.
+                        for _, version := range result.Versions {
+                                info := ObjectInfo{
+                                        ETag:           trimEtag(version.ETag),
+                                        Key:            version.Key,
+                                        LastModified:   version.LastModified.Truncate(time.Millisecond),
+                                        Size:           version.Size,
+                                        Owner:          version.Owner,
+                                        StorageClass:   version.StorageClass,
+                                        IsLatest:       version.IsLatest,
+                                        VersionID:      version.VersionID,
+                                        IsDeleteMarker: version.isDeleteMarker,
+                                        UserTags:       version.UserTags,
+                                        UserMetadata:   version.UserMetadata,
+                                        Internal:       version.Internal,
+                                }
+                                select {
+                                // Send object version info.
+                                case resultCh <- info:
+                                        // If receives done from the caller, return here.
+                                case <-ctx.Done():
+                                        return
+                                }
+                        }
+
+                        // Send all common prefixes if any.
+                        // NOTE: prefixes are only present if the request is delimited.
+                        for _, obj := range result.CommonPrefixes {
+                                select {
+                                // Send object prefixes.
+                                case resultCh <- ObjectInfo{Key: obj.Prefix}:
+                                // If receives done from the caller, return here.
+                                case <-ctx.Done():
+                                        return
+                                }
+                        }
+
+                        // If next key marker is present, save it for next request.
+                        if result.NextKeyMarker != "" {
+                                keyMarker = result.NextKeyMarker
+                        }
+
+                        // If next version id marker is present, save it for next request.
+                        if result.NextVersionIDMarker != "" {
+                                versionIDMarker = result.NextVersionIDMarker
+                        }
+
+                        // Listing ends result is not truncated, return right here.
+                        if !result.IsTruncated {
+                                return
+                        }
+                }
+        }(resultCh)
+        return resultCh
+}
+
+// listObjectVersions - (List Object Versions) - List some or all (up to 1000) of the existing objects
+// and their versions in a bucket.
+//
+// You can use the request parameters as selection criteria to return a subset of the objects in a bucket.
+// request parameters :-
+// ---------
+// ?key-marker - Specifies the key to start with when listing objects in a bucket.
+// ?version-id-marker - Specifies the version id marker to start with when listing objects with versions in a bucket.
+// ?delimiter - A delimiter is a character you use to group keys.
+// ?prefix - Limits the response to keys that begin with the specified prefix.
+// ?max-keys - Sets the maximum number of keys returned in the response body.
+func (c *Client) listObjectVersionsQuery(ctx context.Context, bucketName string, opts ListObjectsOptions, keyMarker, versionIDMarker, delimiter string) (ListVersionsResult, error) {
+        // Validate bucket name.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return ListVersionsResult{}, err
+        }
+        // Validate object prefix.
+        if err := s3utils.CheckValidObjectNamePrefix(opts.Prefix); err != nil {
+                return ListVersionsResult{}, err
+        }
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+
+        // Set versions to trigger versioning API
+        urlValues.Set("versions", "")
+
+        // Set object prefix, prefix value to be set to empty is okay.
+        urlValues.Set("prefix", opts.Prefix)
+
+        // Set delimiter, delimiter value to be set to empty is okay.
+        urlValues.Set("delimiter", delimiter)
+
+        // Set object marker.
+        if keyMarker != "" {
+                urlValues.Set("key-marker", keyMarker)
+        }
+
+        // Set max keys.
+        if opts.MaxKeys > 0 {
+                urlValues.Set("max-keys", fmt.Sprintf("%d", opts.MaxKeys))
+        }
+
+        // Set version ID marker
+        if versionIDMarker != "" {
+                urlValues.Set("version-id-marker", versionIDMarker)
+        }
+
+        if opts.WithMetadata {
+                urlValues.Set("metadata", "true")
+        }
+
+        // Always set encoding-type
+        urlValues.Set("encoding-type", "url")
+
+        // Execute GET on bucket to list objects.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+                customHeader:     opts.headers,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return ListVersionsResult{}, err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return ListVersionsResult{}, httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+
+        // Decode ListVersionsResult XML.
+        listObjectVersionsOutput := ListVersionsResult{}
+        err = xmlDecoder(resp.Body, &listObjectVersionsOutput)
+        if err != nil {
+                return ListVersionsResult{}, err
+        }
+
+        for i, obj := range listObjectVersionsOutput.Versions {
+                listObjectVersionsOutput.Versions[i].Key, err = decodeS3Name(obj.Key, listObjectVersionsOutput.EncodingType)
+                if err != nil {
+                        return listObjectVersionsOutput, err
+                }
+        }
+
+        for i, obj := range listObjectVersionsOutput.CommonPrefixes {
+                listObjectVersionsOutput.CommonPrefixes[i].Prefix, err = decodeS3Name(obj.Prefix, listObjectVersionsOutput.EncodingType)
+                if err != nil {
+                        return listObjectVersionsOutput, err
+                }
+        }
+
+        if listObjectVersionsOutput.NextKeyMarker != "" {
+                listObjectVersionsOutput.NextKeyMarker, err = decodeS3Name(listObjectVersionsOutput.NextKeyMarker, listObjectVersionsOutput.EncodingType)
+                if err != nil {
+                        return listObjectVersionsOutput, err
+                }
+        }
+
+        return listObjectVersionsOutput, nil
+}
+
+// listObjects - (List Objects) - List some or all (up to 1000) of the objects in a bucket.
+//
+// You can use the request parameters as selection criteria to return a subset of the objects in a bucket.
+// request parameters :-
+// ---------
+// ?marker - Specifies the key to start with when listing objects in a bucket.
+// ?delimiter - A delimiter is a character you use to group keys.
+// ?prefix - Limits the response to keys that begin with the specified prefix.
+// ?max-keys - Sets the maximum number of keys returned in the response body.
+func (c *Client) listObjectsQuery(ctx context.Context, bucketName, objectPrefix, objectMarker, delimiter string, maxkeys int, headers http.Header) (ListBucketResult, error) {
+        // Validate bucket name.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return ListBucketResult{}, err
+        }
+        // Validate object prefix.
+        if err := s3utils.CheckValidObjectNamePrefix(objectPrefix); err != nil {
+                return ListBucketResult{}, err
+        }
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+
+        // Set object prefix, prefix value to be set to empty is okay.
+        urlValues.Set("prefix", objectPrefix)
+
+        // Set delimiter, delimiter value to be set to empty is okay.
+        urlValues.Set("delimiter", delimiter)
+
+        // Set object marker.
+        if objectMarker != "" {
+                urlValues.Set("marker", objectMarker)
+        }
+
+        // Set max keys.
+        if maxkeys > 0 {
+                urlValues.Set("max-keys", fmt.Sprintf("%d", maxkeys))
+        }
+
+        // Always set encoding-type
+        urlValues.Set("encoding-type", "url")
+
+        // Execute GET on bucket to list objects.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+                customHeader:     headers,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return ListBucketResult{}, err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return ListBucketResult{}, httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+        // Decode listBuckets XML.
+        listBucketResult := ListBucketResult{}
+        err = xmlDecoder(resp.Body, &listBucketResult)
+        if err != nil {
+                return listBucketResult, err
+        }
+
+        for i, obj := range listBucketResult.Contents {
+                listBucketResult.Contents[i].Key, err = decodeS3Name(obj.Key, listBucketResult.EncodingType)
+                if err != nil {
+                        return listBucketResult, err
+                }
+                listBucketResult.Contents[i].LastModified = listBucketResult.Contents[i].LastModified.Truncate(time.Millisecond)
+        }
+
+        for i, obj := range listBucketResult.CommonPrefixes {
+                listBucketResult.CommonPrefixes[i].Prefix, err = decodeS3Name(obj.Prefix, listBucketResult.EncodingType)
+                if err != nil {
+                        return listBucketResult, err
+                }
+        }
+
+        if listBucketResult.NextMarker != "" {
+                listBucketResult.NextMarker, err = decodeS3Name(listBucketResult.NextMarker, listBucketResult.EncodingType)
+                if err != nil {
+                        return listBucketResult, err
+                }
+        }
+
+        return listBucketResult, nil
+}
+
+// ListObjectsOptions holds all options of a list object request
+type ListObjectsOptions struct {
+        // Include objects versions in the listing
+        WithVersions bool
+        // Include objects metadata in the listing
+        WithMetadata bool
+        // Only list objects with the prefix
+        Prefix string
+        // Ignore '/' delimiter
+        Recursive bool
+        // The maximum number of objects requested per
+        // batch, advanced use-case not useful for most
+        // applications
+        MaxKeys int
+        // StartAfter start listing lexically at this
+        // object onwards, this value can also be set
+        // for Marker when `UseV1` is set to true.
+        StartAfter string
+
+        // Use the deprecated list objects V1 API
+        UseV1 bool
+
+        headers http.Header
+}
+
+// Set adds a key value pair to the options. The
+// key-value pair will be part of the HTTP GET request
+// headers.
+func (o *ListObjectsOptions) Set(key, value string) {
+        if o.headers == nil {
+                o.headers = make(http.Header)
+        }
+        o.headers.Set(key, value)
+}
+
+// ListObjects returns objects list after evaluating the passed options.
+//
+//      api := client.New(....)
+//      for object := range api.ListObjects(ctx, "mytestbucket", minio.ListObjectsOptions{Prefix: "starthere", Recursive:true}) {
+//          fmt.Println(object)
+//      }
+//
+// If caller cancels the context, then the last entry on the 'chan ObjectInfo' will be the context.Error()
+// caller must drain the channel entirely and wait until channel is closed before proceeding, without
+// waiting on the channel to be closed completely you might leak goroutines.
+func (c *Client) ListObjects(ctx context.Context, bucketName string, opts ListObjectsOptions) <-chan ObjectInfo {
+        if opts.WithVersions {
+                return c.listObjectVersions(ctx, bucketName, opts)
+        }
+
+        // Use legacy list objects v1 API
+        if opts.UseV1 {
+                return c.listObjects(ctx, bucketName, opts)
+        }
+
+        // Check whether this is snowball region, if yes ListObjectsV2 doesn't work, fallback to listObjectsV1.
+        if location, ok := c.bucketLocCache.Get(bucketName); ok {
+                if location == "snowball" {
+                        return c.listObjects(ctx, bucketName, opts)
+                }
+        }
+
+        return c.listObjectsV2(ctx, bucketName, opts)
+}
+
+// ListIncompleteUploads - List incompletely uploaded multipart objects.
+//
+// ListIncompleteUploads lists all incompleted objects matching the
+// objectPrefix from the specified bucket. If recursion is enabled
+// it would list all subdirectories and all its contents.
+//
+// Your input parameters are just bucketName, objectPrefix, recursive.
+// If you enable recursive as 'true' this function will return back all
+// the multipart objects in a given bucket name.
+//
+//      api := client.New(....)
+//      // Recurively list all objects in 'mytestbucket'
+//      recursive := true
+//      for message := range api.ListIncompleteUploads(context.Background(), "mytestbucket", "starthere", recursive) {
+//          fmt.Println(message)
+//      }
+func (c *Client) ListIncompleteUploads(ctx context.Context, bucketName, objectPrefix string, recursive bool) <-chan ObjectMultipartInfo {
+        return c.listIncompleteUploads(ctx, bucketName, objectPrefix, recursive)
+}
+
+// contextCanceled returns whether a context is canceled.
+func contextCanceled(ctx context.Context) bool {
+        select {
+        case <-ctx.Done():
+                return true
+        default:
+                return false
+        }
+}
+
+// listIncompleteUploads lists all incomplete uploads.
+func (c *Client) listIncompleteUploads(ctx context.Context, bucketName, objectPrefix string, recursive bool) <-chan ObjectMultipartInfo {
+        // Allocate channel for multipart uploads.
+        objectMultipartStatCh := make(chan ObjectMultipartInfo, 1)
+        // Delimiter is set to "/" by default.
+        delimiter := "/"
+        if recursive {
+                // If recursive do not delimit.
+                delimiter = ""
+        }
+        // Validate bucket name.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                defer close(objectMultipartStatCh)
+                objectMultipartStatCh <- ObjectMultipartInfo{
+                        Err: err,
+                }
+                return objectMultipartStatCh
+        }
+        // Validate incoming object prefix.
+        if err := s3utils.CheckValidObjectNamePrefix(objectPrefix); err != nil {
+                defer close(objectMultipartStatCh)
+                objectMultipartStatCh <- ObjectMultipartInfo{
+                        Err: err,
+                }
+                return objectMultipartStatCh
+        }
+        go func(objectMultipartStatCh chan<- ObjectMultipartInfo) {
+                defer func() {
+                        if contextCanceled(ctx) {
+                                objectMultipartStatCh <- ObjectMultipartInfo{
+                                        Err: ctx.Err(),
+                                }
+                        }
+                        close(objectMultipartStatCh)
+                }()
+
+                // object and upload ID marker for future requests.
+                var objectMarker string
+                var uploadIDMarker string
+                for {
+                        // list all multipart uploads.
+                        result, err := c.listMultipartUploadsQuery(ctx, bucketName, objectMarker, uploadIDMarker, objectPrefix, delimiter, 0)
+                        if err != nil {
+                                objectMultipartStatCh <- ObjectMultipartInfo{
+                                        Err: err,
+                                }
+                                return
+                        }
+                        objectMarker = result.NextKeyMarker
+                        uploadIDMarker = result.NextUploadIDMarker
+
+                        // Send all multipart uploads.
+                        for _, obj := range result.Uploads {
+                                // Calculate total size of the uploaded parts if 'aggregateSize' is enabled.
+                                select {
+                                // Send individual uploads here.
+                                case objectMultipartStatCh <- obj:
+                                // If the context is canceled
+                                case <-ctx.Done():
+                                        return
+                                }
+                        }
+                        // Send all common prefixes if any.
+                        // NOTE: prefixes are only present if the request is delimited.
+                        for _, obj := range result.CommonPrefixes {
+                                select {
+                                // Send delimited prefixes here.
+                                case objectMultipartStatCh <- ObjectMultipartInfo{Key: obj.Prefix, Size: 0}:
+                                // If context is canceled.
+                                case <-ctx.Done():
+                                        return
+                                }
+                        }
+                        // Listing ends if result not truncated, return right here.
+                        if !result.IsTruncated {
+                                return
+                        }
+                }
+        }(objectMultipartStatCh)
+        // return.
+        return objectMultipartStatCh
+}
+
+// listMultipartUploadsQuery - (List Multipart Uploads).
+//   - Lists some or all (up to 1000) in-progress multipart uploads in a bucket.
+//
+// You can use the request parameters as selection criteria to return a subset of the uploads in a bucket.
+// request parameters. :-
+// ---------
+// ?key-marker - Specifies the multipart upload after which listing should begin.
+// ?upload-id-marker - Together with key-marker specifies the multipart upload after which listing should begin.
+// ?delimiter - A delimiter is a character you use to group keys.
+// ?prefix - Limits the response to keys that begin with the specified prefix.
+// ?max-uploads - Sets the maximum number of multipart uploads returned in the response body.
+func (c *Client) listMultipartUploadsQuery(ctx context.Context, bucketName, keyMarker, uploadIDMarker, prefix, delimiter string, maxUploads int) (ListMultipartUploadsResult, error) {
+        // Get resources properly escaped and lined up before using them in http request.
+        urlValues := make(url.Values)
+        // Set uploads.
+        urlValues.Set("uploads", "")
+        // Set object key marker.
+        if keyMarker != "" {
+                urlValues.Set("key-marker", keyMarker)
+        }
+        // Set upload id marker.
+        if uploadIDMarker != "" {
+                urlValues.Set("upload-id-marker", uploadIDMarker)
+        }
+
+        // Set object prefix, prefix value to be set to empty is okay.
+        urlValues.Set("prefix", prefix)
+
+        // Set delimiter, delimiter value to be set to empty is okay.
+        urlValues.Set("delimiter", delimiter)
+
+        // Always set encoding-type
+        urlValues.Set("encoding-type", "url")
+
+        // maxUploads should be 1000 or less.
+        if maxUploads > 0 {
+                // Set max-uploads.
+                urlValues.Set("max-uploads", fmt.Sprintf("%d", maxUploads))
+        }
+
+        // Execute GET on bucketName to list multipart uploads.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return ListMultipartUploadsResult{}, err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return ListMultipartUploadsResult{}, httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+        // Decode response body.
+        listMultipartUploadsResult := ListMultipartUploadsResult{}
+        err = xmlDecoder(resp.Body, &listMultipartUploadsResult)
+        if err != nil {
+                return listMultipartUploadsResult, err
+        }
+
+        listMultipartUploadsResult.NextKeyMarker, err = decodeS3Name(listMultipartUploadsResult.NextKeyMarker, listMultipartUploadsResult.EncodingType)
+        if err != nil {
+                return listMultipartUploadsResult, err
+        }
+
+        listMultipartUploadsResult.NextUploadIDMarker, err = decodeS3Name(listMultipartUploadsResult.NextUploadIDMarker, listMultipartUploadsResult.EncodingType)
+        if err != nil {
+                return listMultipartUploadsResult, err
+        }
+
+        for i, obj := range listMultipartUploadsResult.Uploads {
+                listMultipartUploadsResult.Uploads[i].Key, err = decodeS3Name(obj.Key, listMultipartUploadsResult.EncodingType)
+                if err != nil {
+                        return listMultipartUploadsResult, err
+                }
+        }
+
+        for i, obj := range listMultipartUploadsResult.CommonPrefixes {
+                listMultipartUploadsResult.CommonPrefixes[i].Prefix, err = decodeS3Name(obj.Prefix, listMultipartUploadsResult.EncodingType)
+                if err != nil {
+                        return listMultipartUploadsResult, err
+                }
+        }
+
+        return listMultipartUploadsResult, nil
+}
+
+// listObjectParts list all object parts recursively.
+//
+//lint:ignore U1000 Keep this around
+func (c *Client) listObjectParts(ctx context.Context, bucketName, objectName, uploadID string) (partsInfo map[int]ObjectPart, err error) {
+        // Part number marker for the next batch of request.
+        var nextPartNumberMarker int
+        partsInfo = make(map[int]ObjectPart)
+        for {
+                // Get list of uploaded parts a maximum of 1000 per request.
+                listObjPartsResult, err := c.listObjectPartsQuery(ctx, bucketName, objectName, uploadID, nextPartNumberMarker, 1000)
+                if err != nil {
+                        return nil, err
+                }
+                // Append to parts info.
+                for _, part := range listObjPartsResult.ObjectParts {
+                        // Trim off the odd double quotes from ETag in the beginning and end.
+                        part.ETag = trimEtag(part.ETag)
+                        partsInfo[part.PartNumber] = part
+                }
+                // Keep part number marker, for the next iteration.
+                nextPartNumberMarker = listObjPartsResult.NextPartNumberMarker
+                // Listing ends result is not truncated, return right here.
+                if !listObjPartsResult.IsTruncated {
+                        break
+                }
+        }
+
+        // Return all the parts.
+        return partsInfo, nil
+}
+
+// findUploadIDs lists all incomplete uploads and find the uploadIDs of the matching object name.
+func (c *Client) findUploadIDs(ctx context.Context, bucketName, objectName string) ([]string, error) {
+        var uploadIDs []string
+        // Make list incomplete uploads recursive.
+        isRecursive := true
+        // List all incomplete uploads.
+        for mpUpload := range c.listIncompleteUploads(ctx, bucketName, objectName, isRecursive) {
+                if mpUpload.Err != nil {
+                        return nil, mpUpload.Err
+                }
+                if objectName == mpUpload.Key {
+                        uploadIDs = append(uploadIDs, mpUpload.UploadID)
+                }
+        }
+        // Return the latest upload id.
+        return uploadIDs, nil
+}
+
+// listObjectPartsQuery (List Parts query)
+//   - lists some or all (up to 1000) parts that have been uploaded
+//     for a specific multipart upload
+//
+// You can use the request parameters as selection criteria to return
+// a subset of the uploads in a bucket, request parameters :-
+// ---------
+// ?part-number-marker - Specifies the part after which listing should
+// begin.
+// ?max-parts - Maximum parts to be listed per request.
+func (c *Client) listObjectPartsQuery(ctx context.Context, bucketName, objectName, uploadID string, partNumberMarker, maxParts int) (ListObjectPartsResult, error) {
+        // Get resources properly escaped and lined up before using them in http request.
+        urlValues := make(url.Values)
+        // Set part number marker.
+        urlValues.Set("part-number-marker", fmt.Sprintf("%d", partNumberMarker))
+        // Set upload id.
+        urlValues.Set("uploadId", uploadID)
+
+        // maxParts should be 1000 or less.
+        if maxParts > 0 {
+                // Set max parts.
+                urlValues.Set("max-parts", fmt.Sprintf("%d", maxParts))
+        }
+
+        // Execute GET on objectName to get list of parts.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:       bucketName,
+                objectName:       objectName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return ListObjectPartsResult{}, err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return ListObjectPartsResult{}, httpRespToErrorResponse(resp, bucketName, objectName)
+                }
+        }
+        // Decode list object parts XML.
+        listObjectPartsResult := ListObjectPartsResult{}
+        err = xmlDecoder(resp.Body, &listObjectPartsResult)
+        if err != nil {
+                return listObjectPartsResult, err
+        }
+        return listObjectPartsResult, nil
+}
+
+// Decode an S3 object name according to the encoding type
+func decodeS3Name(name, encodingType string) (string, error) {
+        switch encodingType {
+        case "url":
+                return url.QueryUnescape(name)
+        default:
+                return name, nil
+        }
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-object-legal-hold.go b/vendor/github.com/minio/minio-go/v7/api-object-legal-hold.go
new file mode 100644
index 0000000..0c027d5
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-object-legal-hold.go
@@ -0,0 +1,176 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2020 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/xml"
+        "fmt"
+        "net/http"
+        "net/url"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// objectLegalHold - object legal hold specified in
+// https://docs.aws.amazon.com/AmazonS3/latest/API/archive-RESTObjectPUTLegalHold.html
+type objectLegalHold struct {
+        XMLNS   string          `xml:"xmlns,attr,omitempty"`
+        XMLName xml.Name        `xml:"LegalHold"`
+        Status  LegalHoldStatus `xml:"Status,omitempty"`
+}
+
+// PutObjectLegalHoldOptions represents options specified by user for PutObjectLegalHold call
+type PutObjectLegalHoldOptions struct {
+        VersionID string
+        Status    *LegalHoldStatus
+}
+
+// GetObjectLegalHoldOptions represents options specified by user for GetObjectLegalHold call
+type GetObjectLegalHoldOptions struct {
+        VersionID string
+}
+
+// LegalHoldStatus - object legal hold status.
+type LegalHoldStatus string
+
+const (
+        // LegalHoldEnabled indicates legal hold is enabled
+        LegalHoldEnabled LegalHoldStatus = "ON"
+
+        // LegalHoldDisabled indicates legal hold is disabled
+        LegalHoldDisabled LegalHoldStatus = "OFF"
+)
+
+func (r LegalHoldStatus) String() string {
+        return string(r)
+}
+
+// IsValid - check whether this legal hold status is valid or not.
+func (r LegalHoldStatus) IsValid() bool {
+        return r == LegalHoldEnabled || r == LegalHoldDisabled
+}
+
+func newObjectLegalHold(status *LegalHoldStatus) (*objectLegalHold, error) {
+        if status == nil {
+                return nil, fmt.Errorf("Status not set")
+        }
+        if !status.IsValid() {
+                return nil, fmt.Errorf("invalid legal hold status `%v`", status)
+        }
+        legalHold := &objectLegalHold{
+                Status: *status,
+        }
+        return legalHold, nil
+}
+
+// PutObjectLegalHold : sets object legal hold for a given object and versionID.
+func (c *Client) PutObjectLegalHold(ctx context.Context, bucketName, objectName string, opts PutObjectLegalHoldOptions) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return err
+        }
+
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("legal-hold", "")
+
+        if opts.VersionID != "" {
+                urlValues.Set("versionId", opts.VersionID)
+        }
+
+        lh, err := newObjectLegalHold(opts.Status)
+        if err != nil {
+                return err
+        }
+
+        lhData, err := xml.Marshal(lh)
+        if err != nil {
+                return err
+        }
+
+        reqMetadata := requestMetadata{
+                bucketName:       bucketName,
+                objectName:       objectName,
+                queryValues:      urlValues,
+                contentBody:      bytes.NewReader(lhData),
+                contentLength:    int64(len(lhData)),
+                contentMD5Base64: sumMD5Base64(lhData),
+                contentSHA256Hex: sum256Hex(lhData),
+        }
+
+        // Execute PUT Object Legal Hold.
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
+                        return httpRespToErrorResponse(resp, bucketName, objectName)
+                }
+        }
+        return nil
+}
+
+// GetObjectLegalHold gets legal-hold status of given object.
+func (c *Client) GetObjectLegalHold(ctx context.Context, bucketName, objectName string, opts GetObjectLegalHoldOptions) (status *LegalHoldStatus, err error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return nil, err
+        }
+
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return nil, err
+        }
+        urlValues := make(url.Values)
+        urlValues.Set("legal-hold", "")
+
+        if opts.VersionID != "" {
+                urlValues.Set("versionId", opts.VersionID)
+        }
+
+        // Execute GET on bucket to list objects.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:       bucketName,
+                objectName:       objectName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return nil, err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return nil, httpRespToErrorResponse(resp, bucketName, objectName)
+                }
+        }
+        lh := &objectLegalHold{}
+        if err = xml.NewDecoder(resp.Body).Decode(lh); err != nil {
+                return nil, err
+        }
+
+        return &lh.Status, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-object-lock.go b/vendor/github.com/minio/minio-go/v7/api-object-lock.go
new file mode 100644
index 0000000..f0a4398
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-object-lock.go
@@ -0,0 +1,241 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2019 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/xml"
+        "fmt"
+        "net/http"
+        "net/url"
+        "time"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// RetentionMode - object retention mode.
+type RetentionMode string
+
+const (
+        // Governance - governance mode.
+        Governance RetentionMode = "GOVERNANCE"
+
+        // Compliance - compliance mode.
+        Compliance RetentionMode = "COMPLIANCE"
+)
+
+func (r RetentionMode) String() string {
+        return string(r)
+}
+
+// IsValid - check whether this retention mode is valid or not.
+func (r RetentionMode) IsValid() bool {
+        return r == Governance || r == Compliance
+}
+
+// ValidityUnit - retention validity unit.
+type ValidityUnit string
+
+const (
+        // Days - denotes no. of days.
+        Days ValidityUnit = "DAYS"
+
+        // Years - denotes no. of years.
+        Years ValidityUnit = "YEARS"
+)
+
+func (unit ValidityUnit) String() string {
+        return string(unit)
+}
+
+// IsValid - check whether this validity unit is valid or not.
+func (unit ValidityUnit) isValid() bool {
+        return unit == Days || unit == Years
+}
+
+// Retention - bucket level retention configuration.
+type Retention struct {
+        Mode     RetentionMode
+        Validity time.Duration
+}
+
+func (r Retention) String() string {
+        return fmt.Sprintf("{Mode:%v, Validity:%v}", r.Mode, r.Validity)
+}
+
+// IsEmpty - returns whether retention is empty or not.
+func (r Retention) IsEmpty() bool {
+        return r.Mode == "" || r.Validity == 0
+}
+
+// objectLockConfig - object lock configuration specified in
+// https://docs.aws.amazon.com/AmazonS3/latest/API/Type_API_ObjectLockConfiguration.html
+type objectLockConfig struct {
+        XMLNS             string   `xml:"xmlns,attr,omitempty"`
+        XMLName           xml.Name `xml:"ObjectLockConfiguration"`
+        ObjectLockEnabled string   `xml:"ObjectLockEnabled"`
+        Rule              *struct {
+                DefaultRetention struct {
+                        Mode  RetentionMode `xml:"Mode"`
+                        Days  *uint         `xml:"Days"`
+                        Years *uint         `xml:"Years"`
+                } `xml:"DefaultRetention"`
+        } `xml:"Rule,omitempty"`
+}
+
+func newObjectLockConfig(mode *RetentionMode, validity *uint, unit *ValidityUnit) (*objectLockConfig, error) {
+        config := &objectLockConfig{
+                ObjectLockEnabled: "Enabled",
+        }
+
+        if mode != nil && validity != nil && unit != nil {
+                if !mode.IsValid() {
+                        return nil, fmt.Errorf("invalid retention mode `%v`", mode)
+                }
+
+                if !unit.isValid() {
+                        return nil, fmt.Errorf("invalid validity unit `%v`", unit)
+                }
+
+                config.Rule = &struct {
+                        DefaultRetention struct {
+                                Mode  RetentionMode `xml:"Mode"`
+                                Days  *uint         `xml:"Days"`
+                                Years *uint         `xml:"Years"`
+                        } `xml:"DefaultRetention"`
+                }{}
+
+                config.Rule.DefaultRetention.Mode = *mode
+                if *unit == Days {
+                        config.Rule.DefaultRetention.Days = validity
+                } else {
+                        config.Rule.DefaultRetention.Years = validity
+                }
+
+                return config, nil
+        }
+
+        if mode == nil && validity == nil && unit == nil {
+                return config, nil
+        }
+
+        return nil, fmt.Errorf("all of retention mode, validity and validity unit must be passed")
+}
+
+// SetBucketObjectLockConfig sets object lock configuration in given bucket. mode, validity and unit are either all set or all nil.
+func (c *Client) SetBucketObjectLockConfig(ctx context.Context, bucketName string, mode *RetentionMode, validity *uint, unit *ValidityUnit) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("object-lock", "")
+
+        config, err := newObjectLockConfig(mode, validity, unit)
+        if err != nil {
+                return err
+        }
+
+        configData, err := xml.Marshal(config)
+        if err != nil {
+                return err
+        }
+
+        reqMetadata := requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentBody:      bytes.NewReader(configData),
+                contentLength:    int64(len(configData)),
+                contentMD5Base64: sumMD5Base64(configData),
+                contentSHA256Hex: sum256Hex(configData),
+        }
+
+        // Execute PUT bucket object lock configuration.
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+        return nil
+}
+
+// GetObjectLockConfig gets object lock configuration of given bucket.
+func (c *Client) GetObjectLockConfig(ctx context.Context, bucketName string) (objectLock string, mode *RetentionMode, validity *uint, unit *ValidityUnit, err error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return "", nil, nil, nil, err
+        }
+
+        urlValues := make(url.Values)
+        urlValues.Set("object-lock", "")
+
+        // Execute GET on bucket to list objects.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:       bucketName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return "", nil, nil, nil, err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return "", nil, nil, nil, httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+        config := &objectLockConfig{}
+        if err = xml.NewDecoder(resp.Body).Decode(config); err != nil {
+                return "", nil, nil, nil, err
+        }
+
+        if config.Rule != nil {
+                mode = &config.Rule.DefaultRetention.Mode
+                if config.Rule.DefaultRetention.Days != nil {
+                        validity = config.Rule.DefaultRetention.Days
+                        days := Days
+                        unit = &days
+                } else {
+                        validity = config.Rule.DefaultRetention.Years
+                        years := Years
+                        unit = &years
+                }
+                return config.ObjectLockEnabled, mode, validity, unit, nil
+        }
+        return config.ObjectLockEnabled, nil, nil, nil, nil
+}
+
+// GetBucketObjectLockConfig gets object lock configuration of given bucket.
+func (c *Client) GetBucketObjectLockConfig(ctx context.Context, bucketName string) (mode *RetentionMode, validity *uint, unit *ValidityUnit, err error) {
+        _, mode, validity, unit, err = c.GetObjectLockConfig(ctx, bucketName)
+        return mode, validity, unit, err
+}
+
+// SetObjectLockConfig sets object lock configuration in given bucket. mode, validity and unit are either all set or all nil.
+func (c *Client) SetObjectLockConfig(ctx context.Context, bucketName string, mode *RetentionMode, validity *uint, unit *ValidityUnit) error {
+        return c.SetBucketObjectLockConfig(ctx, bucketName, mode, validity, unit)
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-object-retention.go b/vendor/github.com/minio/minio-go/v7/api-object-retention.go
new file mode 100644
index 0000000..b29cb1f
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-object-retention.go
@@ -0,0 +1,165 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2019-2020 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/xml"
+        "fmt"
+        "net/http"
+        "net/url"
+        "time"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// objectRetention - object retention specified in
+// https://docs.aws.amazon.com/AmazonS3/latest/API/Type_API_ObjectLockConfiguration.html
+type objectRetention struct {
+        XMLNS           string        `xml:"xmlns,attr,omitempty"`
+        XMLName         xml.Name      `xml:"Retention"`
+        Mode            RetentionMode `xml:"Mode,omitempty"`
+        RetainUntilDate *time.Time    `type:"timestamp" timestampFormat:"iso8601" xml:"RetainUntilDate,omitempty"`
+}
+
+func newObjectRetention(mode *RetentionMode, date *time.Time) (*objectRetention, error) {
+        objectRetention := &objectRetention{}
+
+        if date != nil && !date.IsZero() {
+                objectRetention.RetainUntilDate = date
+        }
+        if mode != nil {
+                if !mode.IsValid() {
+                        return nil, fmt.Errorf("invalid retention mode `%v`", mode)
+                }
+                objectRetention.Mode = *mode
+        }
+
+        return objectRetention, nil
+}
+
+// PutObjectRetentionOptions represents options specified by user for PutObject call
+type PutObjectRetentionOptions struct {
+        GovernanceBypass bool
+        Mode             *RetentionMode
+        RetainUntilDate  *time.Time
+        VersionID        string
+}
+
+// PutObjectRetention sets object retention for a given object and versionID.
+func (c *Client) PutObjectRetention(ctx context.Context, bucketName, objectName string, opts PutObjectRetentionOptions) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return err
+        }
+
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("retention", "")
+
+        if opts.VersionID != "" {
+                urlValues.Set("versionId", opts.VersionID)
+        }
+
+        retention, err := newObjectRetention(opts.Mode, opts.RetainUntilDate)
+        if err != nil {
+                return err
+        }
+
+        retentionData, err := xml.Marshal(retention)
+        if err != nil {
+                return err
+        }
+
+        // Build headers.
+        headers := make(http.Header)
+
+        if opts.GovernanceBypass {
+                // Set the bypass goverenance retention header
+                headers.Set(amzBypassGovernance, "true")
+        }
+
+        reqMetadata := requestMetadata{
+                bucketName:       bucketName,
+                objectName:       objectName,
+                queryValues:      urlValues,
+                contentBody:      bytes.NewReader(retentionData),
+                contentLength:    int64(len(retentionData)),
+                contentMD5Base64: sumMD5Base64(retentionData),
+                contentSHA256Hex: sum256Hex(retentionData),
+                customHeader:     headers,
+        }
+
+        // Execute PUT Object Retention.
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
+                        return httpRespToErrorResponse(resp, bucketName, objectName)
+                }
+        }
+        return nil
+}
+
+// GetObjectRetention gets retention of given object.
+func (c *Client) GetObjectRetention(ctx context.Context, bucketName, objectName, versionID string) (mode *RetentionMode, retainUntilDate *time.Time, err error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return nil, nil, err
+        }
+
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return nil, nil, err
+        }
+        urlValues := make(url.Values)
+        urlValues.Set("retention", "")
+        if versionID != "" {
+                urlValues.Set("versionId", versionID)
+        }
+        // Execute GET on bucket to list objects.
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:       bucketName,
+                objectName:       objectName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return nil, nil, err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return nil, nil, httpRespToErrorResponse(resp, bucketName, objectName)
+                }
+        }
+        retention := &objectRetention{}
+        if err = xml.NewDecoder(resp.Body).Decode(retention); err != nil {
+                return nil, nil, err
+        }
+
+        return &retention.Mode, retention.RetainUntilDate, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-object-tagging.go b/vendor/github.com/minio/minio-go/v7/api-object-tagging.go
new file mode 100644
index 0000000..6623e26
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-object-tagging.go
@@ -0,0 +1,177 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2020 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/xml"
+        "net/http"
+        "net/url"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+        "github.com/minio/minio-go/v7/pkg/tags"
+)
+
+// PutObjectTaggingOptions holds an object version id
+// to update tag(s) of a specific object version
+type PutObjectTaggingOptions struct {
+        VersionID string
+        Internal  AdvancedObjectTaggingOptions
+}
+
+// AdvancedObjectTaggingOptions for internal use by MinIO server - not intended for client use.
+type AdvancedObjectTaggingOptions struct {
+        ReplicationProxyRequest string
+}
+
+// PutObjectTagging replaces or creates object tag(s) and can target
+// a specific object version in a versioned bucket.
+func (c *Client) PutObjectTagging(ctx context.Context, bucketName, objectName string, otags *tags.Tags, opts PutObjectTaggingOptions) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("tagging", "")
+
+        if opts.VersionID != "" {
+                urlValues.Set("versionId", opts.VersionID)
+        }
+        headers := make(http.Header, 0)
+        if opts.Internal.ReplicationProxyRequest != "" {
+                headers.Set(minIOBucketReplicationProxyRequest, opts.Internal.ReplicationProxyRequest)
+        }
+        reqBytes, err := xml.Marshal(otags)
+        if err != nil {
+                return err
+        }
+
+        reqMetadata := requestMetadata{
+                bucketName:       bucketName,
+                objectName:       objectName,
+                queryValues:      urlValues,
+                contentBody:      bytes.NewReader(reqBytes),
+                contentLength:    int64(len(reqBytes)),
+                contentMD5Base64: sumMD5Base64(reqBytes),
+                customHeader:     headers,
+        }
+
+        // Execute PUT to set a object tagging.
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return httpRespToErrorResponse(resp, bucketName, objectName)
+                }
+        }
+        return nil
+}
+
+// GetObjectTaggingOptions holds the object version ID
+// to fetch the tagging key/value pairs
+type GetObjectTaggingOptions struct {
+        VersionID string
+        Internal  AdvancedObjectTaggingOptions
+}
+
+// GetObjectTagging fetches object tag(s) with options to target
+// a specific object version in a versioned bucket.
+func (c *Client) GetObjectTagging(ctx context.Context, bucketName, objectName string, opts GetObjectTaggingOptions) (*tags.Tags, error) {
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("tagging", "")
+
+        if opts.VersionID != "" {
+                urlValues.Set("versionId", opts.VersionID)
+        }
+        headers := make(http.Header, 0)
+        if opts.Internal.ReplicationProxyRequest != "" {
+                headers.Set(minIOBucketReplicationProxyRequest, opts.Internal.ReplicationProxyRequest)
+        }
+        // Execute GET on object to get object tag(s)
+        resp, err := c.executeMethod(ctx, http.MethodGet, requestMetadata{
+                bucketName:   bucketName,
+                objectName:   objectName,
+                queryValues:  urlValues,
+                customHeader: headers,
+        })
+
+        defer closeResponse(resp)
+        if err != nil {
+                return nil, err
+        }
+
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return nil, httpRespToErrorResponse(resp, bucketName, objectName)
+                }
+        }
+
+        return tags.ParseObjectXML(resp.Body)
+}
+
+// RemoveObjectTaggingOptions holds the version id of the object to remove
+type RemoveObjectTaggingOptions struct {
+        VersionID string
+        Internal  AdvancedObjectTaggingOptions
+}
+
+// RemoveObjectTagging removes object tag(s) with options to control a specific object
+// version in a versioned bucket
+func (c *Client) RemoveObjectTagging(ctx context.Context, bucketName, objectName string, opts RemoveObjectTaggingOptions) error {
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+        urlValues.Set("tagging", "")
+
+        if opts.VersionID != "" {
+                urlValues.Set("versionId", opts.VersionID)
+        }
+        headers := make(http.Header, 0)
+        if opts.Internal.ReplicationProxyRequest != "" {
+                headers.Set(minIOBucketReplicationProxyRequest, opts.Internal.ReplicationProxyRequest)
+        }
+        // Execute DELETE on object to remove object tag(s)
+        resp, err := c.executeMethod(ctx, http.MethodDelete, requestMetadata{
+                bucketName:   bucketName,
+                objectName:   objectName,
+                queryValues:  urlValues,
+                customHeader: headers,
+        })
+
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+
+        if resp != nil {
+                // S3 returns "204 No content" after Object tag deletion.
+                if resp.StatusCode != http.StatusNoContent {
+                        return httpRespToErrorResponse(resp, bucketName, objectName)
+                }
+        }
+        return err
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-presigned.go b/vendor/github.com/minio/minio-go/v7/api-presigned.go
new file mode 100644
index 0000000..9e85f81
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-presigned.go
@@ -0,0 +1,228 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 minio
+
+import (
+        "context"
+        "errors"
+        "net/http"
+        "net/url"
+        "time"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+        "github.com/minio/minio-go/v7/pkg/signer"
+)
+
+// presignURL - Returns a presigned URL for an input 'method'.
+// Expires maximum is 7days - ie. 604800 and minimum is 1.
+func (c *Client) presignURL(ctx context.Context, method, bucketName, objectName string, expires time.Duration, reqParams url.Values, extraHeaders http.Header) (u *url.URL, err error) {
+        // Input validation.
+        if method == "" {
+                return nil, errInvalidArgument("method cannot be empty.")
+        }
+        if err = s3utils.CheckValidBucketName(bucketName); err != nil {
+                return nil, err
+        }
+        if err = isValidExpiry(expires); err != nil {
+                return nil, err
+        }
+
+        // Convert expires into seconds.
+        expireSeconds := int64(expires / time.Second)
+        reqMetadata := requestMetadata{
+                presignURL:         true,
+                bucketName:         bucketName,
+                objectName:         objectName,
+                expires:            expireSeconds,
+                queryValues:        reqParams,
+                extraPresignHeader: extraHeaders,
+        }
+
+        // Instantiate a new request.
+        // Since expires is set newRequest will presign the request.
+        var req *http.Request
+        if req, err = c.newRequest(ctx, method, reqMetadata); err != nil {
+                return nil, err
+        }
+        return req.URL, nil
+}
+
+// PresignedGetObject - Returns a presigned URL to access an object
+// data without credentials. URL can have a maximum expiry of
+// upto 7days or a minimum of 1sec. Additionally you can override
+// a set of response headers using the query parameters.
+func (c *Client) PresignedGetObject(ctx context.Context, bucketName, objectName string, expires time.Duration, reqParams url.Values) (u *url.URL, err error) {
+        if err = s3utils.CheckValidObjectName(objectName); err != nil {
+                return nil, err
+        }
+        return c.presignURL(ctx, http.MethodGet, bucketName, objectName, expires, reqParams, nil)
+}
+
+// PresignedHeadObject - Returns a presigned URL to access
+// object metadata without credentials. URL can have a maximum expiry
+// of upto 7days or a minimum of 1sec. Additionally you can override
+// a set of response headers using the query parameters.
+func (c *Client) PresignedHeadObject(ctx context.Context, bucketName, objectName string, expires time.Duration, reqParams url.Values) (u *url.URL, err error) {
+        if err = s3utils.CheckValidObjectName(objectName); err != nil {
+                return nil, err
+        }
+        return c.presignURL(ctx, http.MethodHead, bucketName, objectName, expires, reqParams, nil)
+}
+
+// PresignedPutObject - Returns a presigned URL to upload an object
+// without credentials. URL can have a maximum expiry of upto 7days
+// or a minimum of 1sec.
+func (c *Client) PresignedPutObject(ctx context.Context, bucketName, objectName string, expires time.Duration) (u *url.URL, err error) {
+        if err = s3utils.CheckValidObjectName(objectName); err != nil {
+                return nil, err
+        }
+        return c.presignURL(ctx, http.MethodPut, bucketName, objectName, expires, nil, nil)
+}
+
+// PresignHeader - similar to Presign() but allows including HTTP headers that
+// will be used to build the signature. The request using the resulting URL will
+// need to have the exact same headers to be added for signature validation to
+// pass.
+//
+// FIXME: The extra header parameter should be included in Presign() in the next
+// major version bump, and this function should then be deprecated.
+func (c *Client) PresignHeader(ctx context.Context, method, bucketName, objectName string, expires time.Duration, reqParams url.Values, extraHeaders http.Header) (u *url.URL, err error) {
+        return c.presignURL(ctx, method, bucketName, objectName, expires, reqParams, extraHeaders)
+}
+
+// Presign - returns a presigned URL for any http method of your choice along
+// with custom request params and extra signed headers. URL can have a maximum
+// expiry of upto 7days or a minimum of 1sec.
+func (c *Client) Presign(ctx context.Context, method, bucketName, objectName string, expires time.Duration, reqParams url.Values) (u *url.URL, err error) {
+        return c.presignURL(ctx, method, bucketName, objectName, expires, reqParams, nil)
+}
+
+// PresignedPostPolicy - Returns POST urlString, form data to upload an object.
+func (c *Client) PresignedPostPolicy(ctx context.Context, p *PostPolicy) (u *url.URL, formData map[string]string, err error) {
+        // Validate input arguments.
+        if p.expiration.IsZero() {
+                return nil, nil, errors.New("Expiration time must be specified")
+        }
+        if _, ok := p.formData["key"]; !ok {
+                return nil, nil, errors.New("object key must be specified")
+        }
+        if _, ok := p.formData["bucket"]; !ok {
+                return nil, nil, errors.New("bucket name must be specified")
+        }
+
+        bucketName := p.formData["bucket"]
+        // Fetch the bucket location.
+        location, err := c.getBucketLocation(ctx, bucketName)
+        if err != nil {
+                return nil, nil, err
+        }
+
+        isVirtualHost := c.isVirtualHostStyleRequest(*c.endpointURL, bucketName)
+
+        u, err = c.makeTargetURL(bucketName, "", location, isVirtualHost, nil)
+        if err != nil {
+                return nil, nil, err
+        }
+
+        // Get credentials from the configured credentials provider.
+        credValues, err := c.credsProvider.Get()
+        if err != nil {
+                return nil, nil, err
+        }
+
+        var (
+                signerType      = credValues.SignerType
+                sessionToken    = credValues.SessionToken
+                accessKeyID     = credValues.AccessKeyID
+                secretAccessKey = credValues.SecretAccessKey
+        )
+
+        if signerType.IsAnonymous() {
+                return nil, nil, errInvalidArgument("Presigned operations are not supported for anonymous credentials")
+        }
+
+        // Keep time.
+        t := time.Now().UTC()
+        // For signature version '2' handle here.
+        if signerType.IsV2() {
+                policyBase64 := p.base64()
+                p.formData["policy"] = policyBase64
+                // For Google endpoint set this value to be 'GoogleAccessId'.
+                if s3utils.IsGoogleEndpoint(*c.endpointURL) {
+                        p.formData["GoogleAccessId"] = accessKeyID
+                } else {
+                        // For all other endpoints set this value to be 'AWSAccessKeyId'.
+                        p.formData["AWSAccessKeyId"] = accessKeyID
+                }
+                // Sign the policy.
+                p.formData["signature"] = signer.PostPresignSignatureV2(policyBase64, secretAccessKey)
+                return u, p.formData, nil
+        }
+
+        // Add date policy.
+        if err = p.addNewPolicy(policyCondition{
+                matchType: "eq",
+                condition: "$x-amz-date",
+                value:     t.Format(iso8601DateFormat),
+        }); err != nil {
+                return nil, nil, err
+        }
+
+        // Add algorithm policy.
+        if err = p.addNewPolicy(policyCondition{
+                matchType: "eq",
+                condition: "$x-amz-algorithm",
+                value:     signV4Algorithm,
+        }); err != nil {
+                return nil, nil, err
+        }
+
+        // Add a credential policy.
+        credential := signer.GetCredential(accessKeyID, location, t, signer.ServiceTypeS3)
+        if err = p.addNewPolicy(policyCondition{
+                matchType: "eq",
+                condition: "$x-amz-credential",
+                value:     credential,
+        }); err != nil {
+                return nil, nil, err
+        }
+
+        if sessionToken != "" {
+                if err = p.addNewPolicy(policyCondition{
+                        matchType: "eq",
+                        condition: "$x-amz-security-token",
+                        value:     sessionToken,
+                }); err != nil {
+                        return nil, nil, err
+                }
+        }
+
+        // Get base64 encoded policy.
+        policyBase64 := p.base64()
+
+        // Fill in the form data.
+        p.formData["policy"] = policyBase64
+        p.formData["x-amz-algorithm"] = signV4Algorithm
+        p.formData["x-amz-credential"] = credential
+        p.formData["x-amz-date"] = t.Format(iso8601DateFormat)
+        if sessionToken != "" {
+                p.formData["x-amz-security-token"] = sessionToken
+        }
+        p.formData["x-amz-signature"] = signer.PostPresignSignatureV4(policyBase64, t, secretAccessKey, location)
+        return u, p.formData, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-put-bucket.go b/vendor/github.com/minio/minio-go/v7/api-put-bucket.go
new file mode 100644
index 0000000..7376669
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-put-bucket.go
@@ -0,0 +1,123 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2020 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/xml"
+        "net/http"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// Bucket operations
+func (c *Client) makeBucket(ctx context.Context, bucketName string, opts MakeBucketOptions) (err error) {
+        // Validate the input arguments.
+        if err := s3utils.CheckValidBucketNameStrict(bucketName); err != nil {
+                return err
+        }
+
+        err = c.doMakeBucket(ctx, bucketName, opts.Region, opts.ObjectLocking)
+        if err != nil && (opts.Region == "" || opts.Region == "us-east-1") {
+                if resp, ok := err.(ErrorResponse); ok && resp.Code == "AuthorizationHeaderMalformed" && resp.Region != "" {
+                        err = c.doMakeBucket(ctx, bucketName, resp.Region, opts.ObjectLocking)
+                }
+        }
+        return err
+}
+
+func (c *Client) doMakeBucket(ctx context.Context, bucketName, location string, objectLockEnabled bool) (err error) {
+        defer func() {
+                // Save the location into cache on a successful makeBucket response.
+                if err == nil {
+                        c.bucketLocCache.Set(bucketName, location)
+                }
+        }()
+
+        // If location is empty, treat is a default region 'us-east-1'.
+        if location == "" {
+                location = "us-east-1"
+                // For custom region clients, default
+                // to custom region instead not 'us-east-1'.
+                if c.region != "" {
+                        location = c.region
+                }
+        }
+        // PUT bucket request metadata.
+        reqMetadata := requestMetadata{
+                bucketName:     bucketName,
+                bucketLocation: location,
+        }
+
+        if objectLockEnabled {
+                headers := make(http.Header)
+                headers.Add("x-amz-bucket-object-lock-enabled", "true")
+                reqMetadata.customHeader = headers
+        }
+
+        // If location is not 'us-east-1' create bucket location config.
+        if location != "us-east-1" && location != "" {
+                createBucketConfig := createBucketConfiguration{}
+                createBucketConfig.Location = location
+                var createBucketConfigBytes []byte
+                createBucketConfigBytes, err = xml.Marshal(createBucketConfig)
+                if err != nil {
+                        return err
+                }
+                reqMetadata.contentMD5Base64 = sumMD5Base64(createBucketConfigBytes)
+                reqMetadata.contentSHA256Hex = sum256Hex(createBucketConfigBytes)
+                reqMetadata.contentBody = bytes.NewReader(createBucketConfigBytes)
+                reqMetadata.contentLength = int64(len(createBucketConfigBytes))
+        }
+
+        // Execute PUT to create a new bucket.
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+
+        // Success.
+        return nil
+}
+
+// MakeBucketOptions holds all options to tweak bucket creation
+type MakeBucketOptions struct {
+        // Bucket location
+        Region string
+        // Enable object locking
+        ObjectLocking bool
+}
+
+// MakeBucket creates a new bucket with bucketName with a context to control cancellations and timeouts.
+//
+// Location is an optional argument, by default all buckets are
+// created in US Standard Region.
+//
+// For Amazon S3 for more supported regions - http://docs.aws.amazon.com/general/latest/gr/rande.html
+// For Google Cloud Storage for more supported regions - https://cloud.google.com/storage/docs/bucket-locations
+func (c *Client) MakeBucket(ctx context.Context, bucketName string, opts MakeBucketOptions) (err error) {
+        return c.makeBucket(ctx, bucketName, opts)
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-put-object-common.go b/vendor/github.com/minio/minio-go/v7/api-put-object-common.go
new file mode 100644
index 0000000..9ccb97c
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-put-object-common.go
@@ -0,0 +1,149 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 minio
+
+import (
+        "context"
+        "io"
+        "math"
+        "os"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+const nullVersionID = "null"
+
+// Verify if reader is *minio.Object
+func isObject(reader io.Reader) (ok bool) {
+        _, ok = reader.(*Object)
+        return
+}
+
+// Verify if reader is a generic ReaderAt
+func isReadAt(reader io.Reader) (ok bool) {
+        var v *os.File
+        v, ok = reader.(*os.File)
+        if ok {
+                // Stdin, Stdout and Stderr all have *os.File type
+                // which happen to also be io.ReaderAt compatible
+                // we need to add special conditions for them to
+                // be ignored by this function.
+                for _, f := range []string{
+                        "/dev/stdin",
+                        "/dev/stdout",
+                        "/dev/stderr",
+                } {
+                        if f == v.Name() {
+                                ok = false
+                                break
+                        }
+                }
+        } else {
+                _, ok = reader.(io.ReaderAt)
+        }
+        return
+}
+
+// OptimalPartInfo - calculate the optimal part info for a given
+// object size.
+//
+// NOTE: Assumption here is that for any object to be uploaded to any S3 compatible
+// object storage it will have the following parameters as constants.
+//
+//      maxPartsCount - 10000
+//      minPartSize - 16MiB
+//      maxMultipartPutObjectSize - 5TiB
+func OptimalPartInfo(objectSize int64, configuredPartSize uint64) (totalPartsCount int, partSize, lastPartSize int64, err error) {
+        // object size is '-1' set it to 5TiB.
+        var unknownSize bool
+        if objectSize == -1 {
+                unknownSize = true
+                objectSize = maxMultipartPutObjectSize
+        }
+
+        // object size is larger than supported maximum.
+        if objectSize > maxMultipartPutObjectSize {
+                err = errEntityTooLarge(objectSize, maxMultipartPutObjectSize, "", "")
+                return
+        }
+
+        var partSizeFlt float64
+        if configuredPartSize > 0 {
+                if int64(configuredPartSize) > objectSize {
+                        err = errEntityTooLarge(int64(configuredPartSize), objectSize, "", "")
+                        return
+                }
+
+                if !unknownSize {
+                        if objectSize > (int64(configuredPartSize) * maxPartsCount) {
+                                err = errInvalidArgument("Part size * max_parts(10000) is lesser than input objectSize.")
+                                return
+                        }
+                }
+
+                if configuredPartSize < absMinPartSize {
+                        err = errInvalidArgument("Input part size is smaller than allowed minimum of 5MiB.")
+                        return
+                }
+
+                if configuredPartSize > maxPartSize {
+                        err = errInvalidArgument("Input part size is bigger than allowed maximum of 5GiB.")
+                        return
+                }
+
+                partSizeFlt = float64(configuredPartSize)
+                if unknownSize {
+                        // If input has unknown size and part size is configured
+                        // keep it to maximum allowed as per 10000 parts.
+                        objectSize = int64(configuredPartSize) * maxPartsCount
+                }
+        } else {
+                configuredPartSize = minPartSize
+                // Use floats for part size for all calculations to avoid
+                // overflows during float64 to int64 conversions.
+                partSizeFlt = float64(objectSize / maxPartsCount)
+                partSizeFlt = math.Ceil(partSizeFlt/float64(configuredPartSize)) * float64(configuredPartSize)
+        }
+
+        // Total parts count.
+        totalPartsCount = int(math.Ceil(float64(objectSize) / partSizeFlt))
+        // Part size.
+        partSize = int64(partSizeFlt)
+        // Last part size.
+        lastPartSize = objectSize - int64(totalPartsCount-1)*partSize
+        return totalPartsCount, partSize, lastPartSize, nil
+}
+
+// getUploadID - fetch upload id if already present for an object name
+// or initiate a new request to fetch a new upload id.
+func (c *Client) newUploadID(ctx context.Context, bucketName, objectName string, opts PutObjectOptions) (uploadID string, err error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return "", err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return "", err
+        }
+
+        // Initiate multipart upload for an object.
+        initMultipartUploadResult, err := c.initiateMultipartUpload(ctx, bucketName, objectName, opts)
+        if err != nil {
+                return "", err
+        }
+        return initMultipartUploadResult.UploadID, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-put-object-fan-out.go b/vendor/github.com/minio/minio-go/v7/api-put-object-fan-out.go
new file mode 100644
index 0000000..0ae9142
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-put-object-fan-out.go
@@ -0,0 +1,164 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2023 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 minio
+
+import (
+        "context"
+        "encoding/json"
+        "errors"
+        "io"
+        "mime/multipart"
+        "net/http"
+        "strconv"
+        "strings"
+        "time"
+
+        "github.com/minio/minio-go/v7/pkg/encrypt"
+)
+
+// PutObjectFanOutEntry is per object entry fan-out metadata
+type PutObjectFanOutEntry struct {
+        Key                string            `json:"key"`
+        UserMetadata       map[string]string `json:"metadata,omitempty"`
+        UserTags           map[string]string `json:"tags,omitempty"`
+        ContentType        string            `json:"contentType,omitempty"`
+        ContentEncoding    string            `json:"contentEncoding,omitempty"`
+        ContentDisposition string            `json:"contentDisposition,omitempty"`
+        ContentLanguage    string            `json:"contentLanguage,omitempty"`
+        CacheControl       string            `json:"cacheControl,omitempty"`
+        Retention          RetentionMode     `json:"retention,omitempty"`
+        RetainUntilDate    *time.Time        `json:"retainUntil,omitempty"`
+}
+
+// PutObjectFanOutRequest this is the request structure sent
+// to the server to fan-out the stream to multiple objects.
+type PutObjectFanOutRequest struct {
+        Entries  []PutObjectFanOutEntry
+        Checksum Checksum
+        SSE      encrypt.ServerSide
+}
+
+// PutObjectFanOutResponse this is the response structure sent
+// by the server upon success or failure for each object
+// fan-out keys. Additionally, this response carries ETag,
+// VersionID and LastModified for each object fan-out.
+type PutObjectFanOutResponse struct {
+        Key          string     `json:"key"`
+        ETag         string     `json:"etag,omitempty"`
+        VersionID    string     `json:"versionId,omitempty"`
+        LastModified *time.Time `json:"lastModified,omitempty"`
+        Error        string     `json:"error,omitempty"`
+}
+
+// PutObjectFanOut - is a variant of PutObject instead of writing a single object from a single
+// stream multiple objects are written, defined via a list of PutObjectFanOutRequests. Each entry
+// in PutObjectFanOutRequest carries an object keyname and its relevant metadata if any. `Key` is
+// mandatory, rest of the other options in PutObjectFanOutRequest are optional.
+func (c *Client) PutObjectFanOut(ctx context.Context, bucket string, fanOutData io.Reader, fanOutReq PutObjectFanOutRequest) ([]PutObjectFanOutResponse, error) {
+        if len(fanOutReq.Entries) == 0 {
+                return nil, errInvalidArgument("fan out requests cannot be empty")
+        }
+
+        policy := NewPostPolicy()
+        policy.SetBucket(bucket)
+        policy.SetKey(strconv.FormatInt(time.Now().UnixNano(), 16))
+
+        // Expires in 15 minutes.
+        policy.SetExpires(time.Now().UTC().Add(15 * time.Minute))
+
+        // Set encryption headers if any.
+        policy.SetEncryption(fanOutReq.SSE)
+
+        // Set checksum headers if any.
+        policy.SetChecksum(fanOutReq.Checksum)
+
+        url, formData, err := c.PresignedPostPolicy(ctx, policy)
+        if err != nil {
+                return nil, err
+        }
+
+        r, w := io.Pipe()
+
+        req, err := http.NewRequest(http.MethodPost, url.String(), r)
+        if err != nil {
+                w.Close()
+                return nil, err
+        }
+
+        var b strings.Builder
+        enc := json.NewEncoder(&b)
+        for _, req := range fanOutReq.Entries {
+                if req.Key == "" {
+                        w.Close()
+                        return nil, errors.New("PutObjectFanOutRequest.Key is mandatory and cannot be empty")
+                }
+                if err = enc.Encode(&req); err != nil {
+                        w.Close()
+                        return nil, err
+                }
+        }
+
+        mwriter := multipart.NewWriter(w)
+        req.Header.Add("Content-Type", mwriter.FormDataContentType())
+
+        go func() {
+                defer w.Close()
+                defer mwriter.Close()
+
+                for k, v := range formData {
+                        if err := mwriter.WriteField(k, v); err != nil {
+                                return
+                        }
+                }
+
+                if err := mwriter.WriteField("x-minio-fanout-list", b.String()); err != nil {
+                        return
+                }
+
+                mw, err := mwriter.CreateFormFile("file", "fanout-content")
+                if err != nil {
+                        return
+                }
+
+                if _, err = io.Copy(mw, fanOutData); err != nil {
+                        return
+                }
+        }()
+
+        resp, err := c.do(req)
+        if err != nil {
+                return nil, err
+        }
+        defer closeResponse(resp)
+
+        if resp.StatusCode != http.StatusOK {
+                return nil, httpRespToErrorResponse(resp, bucket, "fanout-content")
+        }
+
+        dec := json.NewDecoder(resp.Body)
+        fanOutResp := make([]PutObjectFanOutResponse, 0, len(fanOutReq.Entries))
+        for dec.More() {
+                var m PutObjectFanOutResponse
+                if err = dec.Decode(&m); err != nil {
+                        return nil, err
+                }
+                fanOutResp = append(fanOutResp, m)
+        }
+
+        return fanOutResp, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-put-object-file-context.go b/vendor/github.com/minio/minio-go/v7/api-put-object-file-context.go
new file mode 100644
index 0000000..4d29dfc
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-put-object-file-context.go
@@ -0,0 +1,64 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 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 minio
+
+import (
+        "context"
+        "mime"
+        "os"
+        "path/filepath"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// FPutObject - Create an object in a bucket, with contents from file at filePath. Allows request cancellation.
+func (c *Client) FPutObject(ctx context.Context, bucketName, objectName, filePath string, opts PutObjectOptions) (info UploadInfo, err error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return UploadInfo{}, err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return UploadInfo{}, err
+        }
+
+        // Open the referenced file.
+        fileReader, err := os.Open(filePath)
+        // If any error fail quickly here.
+        if err != nil {
+                return UploadInfo{}, err
+        }
+        defer fileReader.Close()
+
+        // Save the file stat.
+        fileStat, err := fileReader.Stat()
+        if err != nil {
+                return UploadInfo{}, err
+        }
+
+        // Save the file size.
+        fileSize := fileStat.Size()
+
+        // Set contentType based on filepath extension if not given or default
+        // value of "application/octet-stream" if the extension has no associated type.
+        if opts.ContentType == "" {
+                if opts.ContentType = mime.TypeByExtension(filepath.Ext(filePath)); opts.ContentType == "" {
+                        opts.ContentType = "application/octet-stream"
+                }
+        }
+        return c.PutObject(ctx, bucketName, objectName, fileReader, fileSize, opts)
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-put-object-multipart.go b/vendor/github.com/minio/minio-go/v7/api-put-object-multipart.go
new file mode 100644
index 0000000..5f117af
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-put-object-multipart.go
@@ -0,0 +1,465 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/base64"
+        "encoding/hex"
+        "encoding/xml"
+        "fmt"
+        "hash/crc32"
+        "io"
+        "net/http"
+        "net/url"
+        "sort"
+        "strconv"
+        "strings"
+
+        "github.com/google/uuid"
+        "github.com/minio/minio-go/v7/pkg/encrypt"
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+func (c *Client) putObjectMultipart(ctx context.Context, bucketName, objectName string, reader io.Reader, size int64,
+        opts PutObjectOptions,
+) (info UploadInfo, err error) {
+        info, err = c.putObjectMultipartNoStream(ctx, bucketName, objectName, reader, opts)
+        if err != nil {
+                errResp := ToErrorResponse(err)
+                // Verify if multipart functionality is not available, if not
+                // fall back to single PutObject operation.
+                if errResp.Code == "AccessDenied" && strings.Contains(errResp.Message, "Access Denied") {
+                        // Verify if size of reader is greater than '5GiB'.
+                        if size > maxSinglePutObjectSize {
+                                return UploadInfo{}, errEntityTooLarge(size, maxSinglePutObjectSize, bucketName, objectName)
+                        }
+                        // Fall back to uploading as single PutObject operation.
+                        return c.putObject(ctx, bucketName, objectName, reader, size, opts)
+                }
+        }
+        return info, err
+}
+
+func (c *Client) putObjectMultipartNoStream(ctx context.Context, bucketName, objectName string, reader io.Reader, opts PutObjectOptions) (info UploadInfo, err error) {
+        // Input validation.
+        if err = s3utils.CheckValidBucketName(bucketName); err != nil {
+                return UploadInfo{}, err
+        }
+        if err = s3utils.CheckValidObjectName(objectName); err != nil {
+                return UploadInfo{}, err
+        }
+
+        // Total data read and written to server. should be equal to
+        // 'size' at the end of the call.
+        var totalUploadedSize int64
+
+        // Complete multipart upload.
+        var complMultipartUpload completeMultipartUpload
+
+        // Calculate the optimal parts info for a given size.
+        totalPartsCount, partSize, _, err := OptimalPartInfo(-1, opts.PartSize)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+
+        // Choose hash algorithms to be calculated by hashCopyN,
+        // avoid sha256 with non-v4 signature request or
+        // HTTPS connection.
+        hashAlgos, hashSums := c.hashMaterials(opts.SendContentMd5, !opts.DisableContentSha256)
+        if len(hashSums) == 0 {
+                if opts.UserMetadata == nil {
+                        opts.UserMetadata = make(map[string]string, 1)
+                }
+                opts.UserMetadata["X-Amz-Checksum-Algorithm"] = "CRC32C"
+        }
+
+        // Initiate a new multipart upload.
+        uploadID, err := c.newUploadID(ctx, bucketName, objectName, opts)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+        delete(opts.UserMetadata, "X-Amz-Checksum-Algorithm")
+
+        defer func() {
+                if err != nil {
+                        c.abortMultipartUpload(ctx, bucketName, objectName, uploadID)
+                }
+        }()
+
+        // Part number always starts with '1'.
+        partNumber := 1
+
+        // Initialize parts uploaded map.
+        partsInfo := make(map[int]ObjectPart)
+
+        // Create a buffer.
+        buf := make([]byte, partSize)
+
+        // Create checksums
+        // CRC32C is ~50% faster on AMD64 @ 30GB/s
+        var crcBytes []byte
+        customHeader := make(http.Header)
+        crc := crc32.New(crc32.MakeTable(crc32.Castagnoli))
+        for partNumber <= totalPartsCount {
+                length, rErr := readFull(reader, buf)
+                if rErr == io.EOF && partNumber > 1 {
+                        break
+                }
+
+                if rErr != nil && rErr != io.ErrUnexpectedEOF && rErr != io.EOF {
+                        return UploadInfo{}, rErr
+                }
+
+                // Calculates hash sums while copying partSize bytes into cw.
+                for k, v := range hashAlgos {
+                        v.Write(buf[:length])
+                        hashSums[k] = v.Sum(nil)
+                        v.Close()
+                }
+
+                // Update progress reader appropriately to the latest offset
+                // as we read from the source.
+                rd := newHook(bytes.NewReader(buf[:length]), opts.Progress)
+
+                // Checksums..
+                var (
+                        md5Base64 string
+                        sha256Hex string
+                )
+
+                if hashSums["md5"] != nil {
+                        md5Base64 = base64.StdEncoding.EncodeToString(hashSums["md5"])
+                }
+                if hashSums["sha256"] != nil {
+                        sha256Hex = hex.EncodeToString(hashSums["sha256"])
+                }
+                if len(hashSums) == 0 {
+                        crc.Reset()
+                        crc.Write(buf[:length])
+                        cSum := crc.Sum(nil)
+                        customHeader.Set("x-amz-checksum-crc32c", base64.StdEncoding.EncodeToString(cSum))
+                        crcBytes = append(crcBytes, cSum...)
+                }
+
+                p := uploadPartParams{bucketName: bucketName, objectName: objectName, uploadID: uploadID, reader: rd, partNumber: partNumber, md5Base64: md5Base64, sha256Hex: sha256Hex, size: int64(length), sse: opts.ServerSideEncryption, streamSha256: !opts.DisableContentSha256, customHeader: customHeader}
+                // Proceed to upload the part.
+                objPart, uerr := c.uploadPart(ctx, p)
+                if uerr != nil {
+                        return UploadInfo{}, uerr
+                }
+
+                // Save successfully uploaded part metadata.
+                partsInfo[partNumber] = objPart
+
+                // Save successfully uploaded size.
+                totalUploadedSize += int64(length)
+
+                // Increment part number.
+                partNumber++
+
+                // For unknown size, Read EOF we break away.
+                // We do not have to upload till totalPartsCount.
+                if rErr == io.EOF {
+                        break
+                }
+        }
+
+        // Loop over total uploaded parts to save them in
+        // Parts array before completing the multipart request.
+        for i := 1; i < partNumber; i++ {
+                part, ok := partsInfo[i]
+                if !ok {
+                        return UploadInfo{}, errInvalidArgument(fmt.Sprintf("Missing part number %d", i))
+                }
+                complMultipartUpload.Parts = append(complMultipartUpload.Parts, CompletePart{
+                        ETag:           part.ETag,
+                        PartNumber:     part.PartNumber,
+                        ChecksumCRC32:  part.ChecksumCRC32,
+                        ChecksumCRC32C: part.ChecksumCRC32C,
+                        ChecksumSHA1:   part.ChecksumSHA1,
+                        ChecksumSHA256: part.ChecksumSHA256,
+                })
+        }
+
+        // Sort all completed parts.
+        sort.Sort(completedParts(complMultipartUpload.Parts))
+        opts = PutObjectOptions{
+                ServerSideEncryption: opts.ServerSideEncryption,
+        }
+        if len(crcBytes) > 0 {
+                // Add hash of hashes.
+                crc.Reset()
+                crc.Write(crcBytes)
+                opts.UserMetadata = map[string]string{"X-Amz-Checksum-Crc32c": base64.StdEncoding.EncodeToString(crc.Sum(nil))}
+        }
+        uploadInfo, err := c.completeMultipartUpload(ctx, bucketName, objectName, uploadID, complMultipartUpload, opts)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+
+        uploadInfo.Size = totalUploadedSize
+        return uploadInfo, nil
+}
+
+// initiateMultipartUpload - Initiates a multipart upload and returns an upload ID.
+func (c *Client) initiateMultipartUpload(ctx context.Context, bucketName, objectName string, opts PutObjectOptions) (initiateMultipartUploadResult, error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return initiateMultipartUploadResult{}, err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return initiateMultipartUploadResult{}, err
+        }
+
+        // Initialize url queries.
+        urlValues := make(url.Values)
+        urlValues.Set("uploads", "")
+
+        if opts.Internal.SourceVersionID != "" {
+                if opts.Internal.SourceVersionID != nullVersionID {
+                        if _, err := uuid.Parse(opts.Internal.SourceVersionID); err != nil {
+                                return initiateMultipartUploadResult{}, errInvalidArgument(err.Error())
+                        }
+                }
+                urlValues.Set("versionId", opts.Internal.SourceVersionID)
+        }
+
+        // Set ContentType header.
+        customHeader := opts.Header()
+
+        reqMetadata := requestMetadata{
+                bucketName:   bucketName,
+                objectName:   objectName,
+                queryValues:  urlValues,
+                customHeader: customHeader,
+        }
+
+        // Execute POST on an objectName to initiate multipart upload.
+        resp, err := c.executeMethod(ctx, http.MethodPost, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return initiateMultipartUploadResult{}, err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return initiateMultipartUploadResult{}, httpRespToErrorResponse(resp, bucketName, objectName)
+                }
+        }
+        // Decode xml for new multipart upload.
+        initiateMultipartUploadResult := initiateMultipartUploadResult{}
+        err = xmlDecoder(resp.Body, &initiateMultipartUploadResult)
+        if err != nil {
+                return initiateMultipartUploadResult, err
+        }
+        return initiateMultipartUploadResult, nil
+}
+
+type uploadPartParams struct {
+        bucketName   string
+        objectName   string
+        uploadID     string
+        reader       io.Reader
+        partNumber   int
+        md5Base64    string
+        sha256Hex    string
+        size         int64
+        sse          encrypt.ServerSide
+        streamSha256 bool
+        customHeader http.Header
+        trailer      http.Header
+}
+
+// uploadPart - Uploads a part in a multipart upload.
+func (c *Client) uploadPart(ctx context.Context, p uploadPartParams) (ObjectPart, error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(p.bucketName); err != nil {
+                return ObjectPart{}, err
+        }
+        if err := s3utils.CheckValidObjectName(p.objectName); err != nil {
+                return ObjectPart{}, err
+        }
+        if p.size > maxPartSize {
+                return ObjectPart{}, errEntityTooLarge(p.size, maxPartSize, p.bucketName, p.objectName)
+        }
+        if p.size <= -1 {
+                return ObjectPart{}, errEntityTooSmall(p.size, p.bucketName, p.objectName)
+        }
+        if p.partNumber <= 0 {
+                return ObjectPart{}, errInvalidArgument("Part number cannot be negative or equal to zero.")
+        }
+        if p.uploadID == "" {
+                return ObjectPart{}, errInvalidArgument("UploadID cannot be empty.")
+        }
+
+        // Get resources properly escaped and lined up before using them in http request.
+        urlValues := make(url.Values)
+        // Set part number.
+        urlValues.Set("partNumber", strconv.Itoa(p.partNumber))
+        // Set upload id.
+        urlValues.Set("uploadId", p.uploadID)
+
+        // Set encryption headers, if any.
+        if p.customHeader == nil {
+                p.customHeader = make(http.Header)
+        }
+        // https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html
+        // Server-side encryption is supported by the S3 Multipart Upload actions.
+        // Unless you are using a customer-provided encryption key, you don't need
+        // to specify the encryption parameters in each UploadPart request.
+        if p.sse != nil && p.sse.Type() == encrypt.SSEC {
+                p.sse.Marshal(p.customHeader)
+        }
+
+        reqMetadata := requestMetadata{
+                bucketName:       p.bucketName,
+                objectName:       p.objectName,
+                queryValues:      urlValues,
+                customHeader:     p.customHeader,
+                contentBody:      p.reader,
+                contentLength:    p.size,
+                contentMD5Base64: p.md5Base64,
+                contentSHA256Hex: p.sha256Hex,
+                streamSha256:     p.streamSha256,
+                trailer:          p.trailer,
+        }
+
+        // Execute PUT on each part.
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return ObjectPart{}, err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return ObjectPart{}, httpRespToErrorResponse(resp, p.bucketName, p.objectName)
+                }
+        }
+        // Once successfully uploaded, return completed part.
+        h := resp.Header
+        objPart := ObjectPart{
+                ChecksumCRC32:  h.Get("x-amz-checksum-crc32"),
+                ChecksumCRC32C: h.Get("x-amz-checksum-crc32c"),
+                ChecksumSHA1:   h.Get("x-amz-checksum-sha1"),
+                ChecksumSHA256: h.Get("x-amz-checksum-sha256"),
+        }
+        objPart.Size = p.size
+        objPart.PartNumber = p.partNumber
+        // Trim off the odd double quotes from ETag in the beginning and end.
+        objPart.ETag = trimEtag(h.Get("ETag"))
+        return objPart, nil
+}
+
+// completeMultipartUpload - Completes a multipart upload by assembling previously uploaded parts.
+func (c *Client) completeMultipartUpload(ctx context.Context, bucketName, objectName, uploadID string,
+        complete completeMultipartUpload, opts PutObjectOptions,
+) (UploadInfo, error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return UploadInfo{}, err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return UploadInfo{}, err
+        }
+
+        // Initialize url queries.
+        urlValues := make(url.Values)
+        urlValues.Set("uploadId", uploadID)
+        // Marshal complete multipart body.
+        completeMultipartUploadBytes, err := xml.Marshal(complete)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+
+        headers := opts.Header()
+        if s3utils.IsAmazonEndpoint(*c.endpointURL) {
+                headers.Del(encrypt.SseKmsKeyID)          // Remove X-Amz-Server-Side-Encryption-Aws-Kms-Key-Id not supported in CompleteMultipartUpload
+                headers.Del(encrypt.SseGenericHeader)     // Remove X-Amz-Server-Side-Encryption not supported in CompleteMultipartUpload
+                headers.Del(encrypt.SseEncryptionContext) // Remove X-Amz-Server-Side-Encryption-Context not supported in CompleteMultipartUpload
+        }
+
+        // Instantiate all the complete multipart buffer.
+        completeMultipartUploadBuffer := bytes.NewReader(completeMultipartUploadBytes)
+        reqMetadata := requestMetadata{
+                bucketName:       bucketName,
+                objectName:       objectName,
+                queryValues:      urlValues,
+                contentBody:      completeMultipartUploadBuffer,
+                contentLength:    int64(len(completeMultipartUploadBytes)),
+                contentSHA256Hex: sum256Hex(completeMultipartUploadBytes),
+                customHeader:     headers,
+        }
+
+        // Execute POST to complete multipart upload for an objectName.
+        resp, err := c.executeMethod(ctx, http.MethodPost, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return UploadInfo{}, httpRespToErrorResponse(resp, bucketName, objectName)
+                }
+        }
+
+        // Read resp.Body into a []bytes to parse for Error response inside the body
+        var b []byte
+        b, err = io.ReadAll(resp.Body)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+        // Decode completed multipart upload response on success.
+        completeMultipartUploadResult := completeMultipartUploadResult{}
+        err = xmlDecoder(bytes.NewReader(b), &completeMultipartUploadResult)
+        if err != nil {
+                // xml parsing failure due to presence an ill-formed xml fragment
+                return UploadInfo{}, err
+        } else if completeMultipartUploadResult.Bucket == "" {
+                // xml's Decode method ignores well-formed xml that don't apply to the type of value supplied.
+                // In this case, it would leave completeMultipartUploadResult with the corresponding zero-values
+                // of the members.
+
+                // Decode completed multipart upload response on failure
+                completeMultipartUploadErr := ErrorResponse{}
+                err = xmlDecoder(bytes.NewReader(b), &completeMultipartUploadErr)
+                if err != nil {
+                        // xml parsing failure due to presence an ill-formed xml fragment
+                        return UploadInfo{}, err
+                }
+                return UploadInfo{}, completeMultipartUploadErr
+        }
+
+        // extract lifecycle expiry date and rule ID
+        expTime, ruleID := amzExpirationToExpiryDateRuleID(resp.Header.Get(amzExpiration))
+
+        return UploadInfo{
+                Bucket:           completeMultipartUploadResult.Bucket,
+                Key:              completeMultipartUploadResult.Key,
+                ETag:             trimEtag(completeMultipartUploadResult.ETag),
+                VersionID:        resp.Header.Get(amzVersionID),
+                Location:         completeMultipartUploadResult.Location,
+                Expiration:       expTime,
+                ExpirationRuleID: ruleID,
+
+                ChecksumSHA256: completeMultipartUploadResult.ChecksumSHA256,
+                ChecksumSHA1:   completeMultipartUploadResult.ChecksumSHA1,
+                ChecksumCRC32:  completeMultipartUploadResult.ChecksumCRC32,
+                ChecksumCRC32C: completeMultipartUploadResult.ChecksumCRC32C,
+        }, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-put-object-streaming.go b/vendor/github.com/minio/minio-go/v7/api-put-object-streaming.go
new file mode 100644
index 0000000..9182d4e
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-put-object-streaming.go
@@ -0,0 +1,809 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/base64"
+        "fmt"
+        "hash/crc32"
+        "io"
+        "net/http"
+        "net/url"
+        "sort"
+        "strings"
+        "sync"
+
+        "github.com/google/uuid"
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// putObjectMultipartStream - upload a large object using
+// multipart upload and streaming signature for signing payload.
+// Comprehensive put object operation involving multipart uploads.
+//
+// Following code handles these types of readers.
+//
+//   - *minio.Object
+//   - Any reader which has a method 'ReadAt()'
+func (c *Client) putObjectMultipartStream(ctx context.Context, bucketName, objectName string,
+        reader io.Reader, size int64, opts PutObjectOptions,
+) (info UploadInfo, err error) {
+        if opts.ConcurrentStreamParts && opts.NumThreads > 1 {
+                info, err = c.putObjectMultipartStreamParallel(ctx, bucketName, objectName, reader, opts)
+        } else if !isObject(reader) && isReadAt(reader) && !opts.SendContentMd5 {
+                // Verify if the reader implements ReadAt and it is not a *minio.Object then we will use parallel uploader.
+                info, err = c.putObjectMultipartStreamFromReadAt(ctx, bucketName, objectName, reader.(io.ReaderAt), size, opts)
+        } else {
+                info, err = c.putObjectMultipartStreamOptionalChecksum(ctx, bucketName, objectName, reader, size, opts)
+        }
+        if err != nil {
+                errResp := ToErrorResponse(err)
+                // Verify if multipart functionality is not available, if not
+                // fall back to single PutObject operation.
+                if errResp.Code == "AccessDenied" && strings.Contains(errResp.Message, "Access Denied") {
+                        // Verify if size of reader is greater than '5GiB'.
+                        if size > maxSinglePutObjectSize {
+                                return UploadInfo{}, errEntityTooLarge(size, maxSinglePutObjectSize, bucketName, objectName)
+                        }
+                        // Fall back to uploading as single PutObject operation.
+                        return c.putObject(ctx, bucketName, objectName, reader, size, opts)
+                }
+        }
+        return info, err
+}
+
+// uploadedPartRes - the response received from a part upload.
+type uploadedPartRes struct {
+        Error   error // Any error encountered while uploading the part.
+        PartNum int   // Number of the part uploaded.
+        Size    int64 // Size of the part uploaded.
+        Part    ObjectPart
+}
+
+type uploadPartReq struct {
+        PartNum int        // Number of the part uploaded.
+        Part    ObjectPart // Size of the part uploaded.
+}
+
+// putObjectMultipartFromReadAt - Uploads files bigger than 128MiB.
+// Supports all readers which implements io.ReaderAt interface
+// (ReadAt method).
+//
+// NOTE: This function is meant to be used for all readers which
+// implement io.ReaderAt which allows us for resuming multipart
+// uploads but reading at an offset, which would avoid re-read the
+// data which was already uploaded. Internally this function uses
+// temporary files for staging all the data, these temporary files are
+// cleaned automatically when the caller i.e http client closes the
+// stream after uploading all the contents successfully.
+func (c *Client) putObjectMultipartStreamFromReadAt(ctx context.Context, bucketName, objectName string,
+        reader io.ReaderAt, size int64, opts PutObjectOptions,
+) (info UploadInfo, err error) {
+        // Input validation.
+        if err = s3utils.CheckValidBucketName(bucketName); err != nil {
+                return UploadInfo{}, err
+        }
+        if err = s3utils.CheckValidObjectName(objectName); err != nil {
+                return UploadInfo{}, err
+        }
+
+        // Calculate the optimal parts info for a given size.
+        totalPartsCount, partSize, lastPartSize, err := OptimalPartInfo(size, opts.PartSize)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+
+        withChecksum := c.trailingHeaderSupport
+        if withChecksum {
+                if opts.UserMetadata == nil {
+                        opts.UserMetadata = make(map[string]string, 1)
+                }
+                opts.UserMetadata["X-Amz-Checksum-Algorithm"] = "CRC32C"
+        }
+        // Initiate a new multipart upload.
+        uploadID, err := c.newUploadID(ctx, bucketName, objectName, opts)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+        delete(opts.UserMetadata, "X-Amz-Checksum-Algorithm")
+
+        // Aborts the multipart upload in progress, if the
+        // function returns any error, since we do not resume
+        // we should purge the parts which have been uploaded
+        // to relinquish storage space.
+        defer func() {
+                if err != nil {
+                        c.abortMultipartUpload(ctx, bucketName, objectName, uploadID)
+                }
+        }()
+
+        // Total data read and written to server. should be equal to 'size' at the end of the call.
+        var totalUploadedSize int64
+
+        // Complete multipart upload.
+        var complMultipartUpload completeMultipartUpload
+
+        // Declare a channel that sends the next part number to be uploaded.
+        uploadPartsCh := make(chan uploadPartReq)
+
+        // Declare a channel that sends back the response of a part upload.
+        uploadedPartsCh := make(chan uploadedPartRes)
+
+        // Used for readability, lastPartNumber is always totalPartsCount.
+        lastPartNumber := totalPartsCount
+
+        partitionCtx, partitionCancel := context.WithCancel(ctx)
+        defer partitionCancel()
+        // Send each part number to the channel to be processed.
+        go func() {
+                defer close(uploadPartsCh)
+
+                for p := 1; p <= totalPartsCount; p++ {
+                        select {
+                        case <-partitionCtx.Done():
+                                return
+                        case uploadPartsCh <- uploadPartReq{PartNum: p}:
+                        }
+                }
+        }()
+
+        // Receive each part number from the channel allowing three parallel uploads.
+        for w := 1; w <= opts.getNumThreads(); w++ {
+                go func(partSize int64) {
+                        for {
+                                var uploadReq uploadPartReq
+                                var ok bool
+                                select {
+                                case <-ctx.Done():
+                                        return
+                                case uploadReq, ok = <-uploadPartsCh:
+                                        if !ok {
+                                                return
+                                        }
+                                        // Each worker will draw from the part channel and upload in parallel.
+                                }
+
+                                // If partNumber was not uploaded we calculate the missing
+                                // part offset and size. For all other part numbers we
+                                // calculate offset based on multiples of partSize.
+                                readOffset := int64(uploadReq.PartNum-1) * partSize
+
+                                // As a special case if partNumber is lastPartNumber, we
+                                // calculate the offset based on the last part size.
+                                if uploadReq.PartNum == lastPartNumber {
+                                        readOffset = size - lastPartSize
+                                        partSize = lastPartSize
+                                }
+
+                                sectionReader := newHook(io.NewSectionReader(reader, readOffset, partSize), opts.Progress)
+                                trailer := make(http.Header, 1)
+                                if withChecksum {
+                                        crc := crc32.New(crc32.MakeTable(crc32.Castagnoli))
+                                        trailer.Set("x-amz-checksum-crc32c", base64.StdEncoding.EncodeToString(crc.Sum(nil)))
+                                        sectionReader = newHashReaderWrapper(sectionReader, crc, func(hash []byte) {
+                                                trailer.Set("x-amz-checksum-crc32c", base64.StdEncoding.EncodeToString(hash))
+                                        })
+                                }
+
+                                // Proceed to upload the part.
+                                p := uploadPartParams{
+                                        bucketName:   bucketName,
+                                        objectName:   objectName,
+                                        uploadID:     uploadID,
+                                        reader:       sectionReader,
+                                        partNumber:   uploadReq.PartNum,
+                                        size:         partSize,
+                                        sse:          opts.ServerSideEncryption,
+                                        streamSha256: !opts.DisableContentSha256,
+                                        sha256Hex:    "",
+                                        trailer:      trailer,
+                                }
+                                objPart, err := c.uploadPart(ctx, p)
+                                if err != nil {
+                                        uploadedPartsCh <- uploadedPartRes{
+                                                Error: err,
+                                        }
+                                        // Exit the goroutine.
+                                        return
+                                }
+
+                                // Save successfully uploaded part metadata.
+                                uploadReq.Part = objPart
+
+                                // Send successful part info through the channel.
+                                uploadedPartsCh <- uploadedPartRes{
+                                        Size:    objPart.Size,
+                                        PartNum: uploadReq.PartNum,
+                                        Part:    uploadReq.Part,
+                                }
+                        }
+                }(partSize)
+        }
+
+        // Gather the responses as they occur and update any
+        // progress bar.
+        for u := 1; u <= totalPartsCount; u++ {
+                select {
+                case <-ctx.Done():
+                        return UploadInfo{}, ctx.Err()
+                case uploadRes := <-uploadedPartsCh:
+                        if uploadRes.Error != nil {
+                                return UploadInfo{}, uploadRes.Error
+                        }
+
+                        // Update the totalUploadedSize.
+                        totalUploadedSize += uploadRes.Size
+                        complMultipartUpload.Parts = append(complMultipartUpload.Parts, CompletePart{
+                                ETag:           uploadRes.Part.ETag,
+                                PartNumber:     uploadRes.Part.PartNumber,
+                                ChecksumCRC32:  uploadRes.Part.ChecksumCRC32,
+                                ChecksumCRC32C: uploadRes.Part.ChecksumCRC32C,
+                                ChecksumSHA1:   uploadRes.Part.ChecksumSHA1,
+                                ChecksumSHA256: uploadRes.Part.ChecksumSHA256,
+                        })
+                }
+        }
+
+        // Verify if we uploaded all the data.
+        if totalUploadedSize != size {
+                return UploadInfo{}, errUnexpectedEOF(totalUploadedSize, size, bucketName, objectName)
+        }
+
+        // Sort all completed parts.
+        sort.Sort(completedParts(complMultipartUpload.Parts))
+
+        opts = PutObjectOptions{
+                ServerSideEncryption: opts.ServerSideEncryption,
+        }
+        if withChecksum {
+                // Add hash of hashes.
+                crc := crc32.New(crc32.MakeTable(crc32.Castagnoli))
+                for _, part := range complMultipartUpload.Parts {
+                        cs, err := base64.StdEncoding.DecodeString(part.ChecksumCRC32C)
+                        if err == nil {
+                                crc.Write(cs)
+                        }
+                }
+                opts.UserMetadata = map[string]string{"X-Amz-Checksum-Crc32c": base64.StdEncoding.EncodeToString(crc.Sum(nil))}
+        }
+
+        uploadInfo, err := c.completeMultipartUpload(ctx, bucketName, objectName, uploadID, complMultipartUpload, opts)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+
+        uploadInfo.Size = totalUploadedSize
+        return uploadInfo, nil
+}
+
+func (c *Client) putObjectMultipartStreamOptionalChecksum(ctx context.Context, bucketName, objectName string,
+        reader io.Reader, size int64, opts PutObjectOptions,
+) (info UploadInfo, err error) {
+        // Input validation.
+        if err = s3utils.CheckValidBucketName(bucketName); err != nil {
+                return UploadInfo{}, err
+        }
+        if err = s3utils.CheckValidObjectName(objectName); err != nil {
+                return UploadInfo{}, err
+        }
+
+        if !opts.SendContentMd5 {
+                if opts.UserMetadata == nil {
+                        opts.UserMetadata = make(map[string]string, 1)
+                }
+                opts.UserMetadata["X-Amz-Checksum-Algorithm"] = "CRC32C"
+        }
+
+        // Calculate the optimal parts info for a given size.
+        totalPartsCount, partSize, lastPartSize, err := OptimalPartInfo(size, opts.PartSize)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+        // Initiates a new multipart request
+        uploadID, err := c.newUploadID(ctx, bucketName, objectName, opts)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+        delete(opts.UserMetadata, "X-Amz-Checksum-Algorithm")
+
+        // Aborts the multipart upload if the function returns
+        // any error, since we do not resume we should purge
+        // the parts which have been uploaded to relinquish
+        // storage space.
+        defer func() {
+                if err != nil {
+                        c.abortMultipartUpload(ctx, bucketName, objectName, uploadID)
+                }
+        }()
+
+        // Create checksums
+        // CRC32C is ~50% faster on AMD64 @ 30GB/s
+        var crcBytes []byte
+        customHeader := make(http.Header)
+        crc := crc32.New(crc32.MakeTable(crc32.Castagnoli))
+        md5Hash := c.md5Hasher()
+        defer md5Hash.Close()
+
+        // Total data read and written to server. should be equal to 'size' at the end of the call.
+        var totalUploadedSize int64
+
+        // Initialize parts uploaded map.
+        partsInfo := make(map[int]ObjectPart)
+
+        // Create a buffer.
+        buf := make([]byte, partSize)
+
+        // Avoid declaring variables in the for loop
+        var md5Base64 string
+
+        // Part number always starts with '1'.
+        var partNumber int
+        for partNumber = 1; partNumber <= totalPartsCount; partNumber++ {
+
+                // Proceed to upload the part.
+                if partNumber == totalPartsCount {
+                        partSize = lastPartSize
+                }
+
+                length, rerr := readFull(reader, buf)
+                if rerr == io.EOF && partNumber > 1 {
+                        break
+                }
+
+                if rerr != nil && rerr != io.ErrUnexpectedEOF && err != io.EOF {
+                        return UploadInfo{}, rerr
+                }
+
+                // Calculate md5sum.
+                if opts.SendContentMd5 {
+                        md5Hash.Reset()
+                        md5Hash.Write(buf[:length])
+                        md5Base64 = base64.StdEncoding.EncodeToString(md5Hash.Sum(nil))
+                } else {
+                        // Add CRC32C instead.
+                        crc.Reset()
+                        crc.Write(buf[:length])
+                        cSum := crc.Sum(nil)
+                        customHeader.Set("x-amz-checksum-crc32c", base64.StdEncoding.EncodeToString(cSum))
+                        crcBytes = append(crcBytes, cSum...)
+                }
+
+                // Update progress reader appropriately to the latest offset
+                // as we read from the source.
+                hooked := newHook(bytes.NewReader(buf[:length]), opts.Progress)
+                p := uploadPartParams{bucketName: bucketName, objectName: objectName, uploadID: uploadID, reader: hooked, partNumber: partNumber, md5Base64: md5Base64, size: partSize, sse: opts.ServerSideEncryption, streamSha256: !opts.DisableContentSha256, customHeader: customHeader}
+                objPart, uerr := c.uploadPart(ctx, p)
+                if uerr != nil {
+                        return UploadInfo{}, uerr
+                }
+
+                // Save successfully uploaded part metadata.
+                partsInfo[partNumber] = objPart
+
+                // Save successfully uploaded size.
+                totalUploadedSize += partSize
+        }
+
+        // Verify if we uploaded all the data.
+        if size > 0 {
+                if totalUploadedSize != size {
+                        return UploadInfo{}, errUnexpectedEOF(totalUploadedSize, size, bucketName, objectName)
+                }
+        }
+
+        // Complete multipart upload.
+        var complMultipartUpload completeMultipartUpload
+
+        // Loop over total uploaded parts to save them in
+        // Parts array before completing the multipart request.
+        for i := 1; i < partNumber; i++ {
+                part, ok := partsInfo[i]
+                if !ok {
+                        return UploadInfo{}, errInvalidArgument(fmt.Sprintf("Missing part number %d", i))
+                }
+                complMultipartUpload.Parts = append(complMultipartUpload.Parts, CompletePart{
+                        ETag:           part.ETag,
+                        PartNumber:     part.PartNumber,
+                        ChecksumCRC32:  part.ChecksumCRC32,
+                        ChecksumCRC32C: part.ChecksumCRC32C,
+                        ChecksumSHA1:   part.ChecksumSHA1,
+                        ChecksumSHA256: part.ChecksumSHA256,
+                })
+        }
+
+        // Sort all completed parts.
+        sort.Sort(completedParts(complMultipartUpload.Parts))
+
+        opts = PutObjectOptions{
+                ServerSideEncryption: opts.ServerSideEncryption,
+        }
+        if len(crcBytes) > 0 {
+                // Add hash of hashes.
+                crc.Reset()
+                crc.Write(crcBytes)
+                opts.UserMetadata = map[string]string{"X-Amz-Checksum-Crc32c": base64.StdEncoding.EncodeToString(crc.Sum(nil))}
+        }
+        uploadInfo, err := c.completeMultipartUpload(ctx, bucketName, objectName, uploadID, complMultipartUpload, opts)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+
+        uploadInfo.Size = totalUploadedSize
+        return uploadInfo, nil
+}
+
+// putObjectMultipartStreamParallel uploads opts.NumThreads parts in parallel.
+// This is expected to take opts.PartSize * opts.NumThreads * (GOGC / 100) bytes of buffer.
+func (c *Client) putObjectMultipartStreamParallel(ctx context.Context, bucketName, objectName string,
+        reader io.Reader, opts PutObjectOptions,
+) (info UploadInfo, err error) {
+        // Input validation.
+        if err = s3utils.CheckValidBucketName(bucketName); err != nil {
+                return UploadInfo{}, err
+        }
+
+        if err = s3utils.CheckValidObjectName(objectName); err != nil {
+                return UploadInfo{}, err
+        }
+
+        if !opts.SendContentMd5 {
+                if opts.UserMetadata == nil {
+                        opts.UserMetadata = make(map[string]string, 1)
+                }
+                opts.UserMetadata["X-Amz-Checksum-Algorithm"] = "CRC32C"
+        }
+
+        // Cancel all when an error occurs.
+        ctx, cancel := context.WithCancel(ctx)
+        defer cancel()
+
+        // Calculate the optimal parts info for a given size.
+        totalPartsCount, partSize, _, err := OptimalPartInfo(-1, opts.PartSize)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+
+        // Initiates a new multipart request
+        uploadID, err := c.newUploadID(ctx, bucketName, objectName, opts)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+        delete(opts.UserMetadata, "X-Amz-Checksum-Algorithm")
+
+        // Aborts the multipart upload if the function returns
+        // any error, since we do not resume we should purge
+        // the parts which have been uploaded to relinquish
+        // storage space.
+        defer func() {
+                if err != nil {
+                        c.abortMultipartUpload(ctx, bucketName, objectName, uploadID)
+                }
+        }()
+
+        // Create checksums
+        // CRC32C is ~50% faster on AMD64 @ 30GB/s
+        var crcBytes []byte
+        crc := crc32.New(crc32.MakeTable(crc32.Castagnoli))
+
+        // Total data read and written to server. should be equal to 'size' at the end of the call.
+        var totalUploadedSize int64
+
+        // Initialize parts uploaded map.
+        partsInfo := make(map[int]ObjectPart)
+
+        // Create a buffer.
+        nBuffers := int64(opts.NumThreads)
+        bufs := make(chan []byte, nBuffers)
+        all := make([]byte, nBuffers*partSize)
+        for i := int64(0); i < nBuffers; i++ {
+                bufs <- all[i*partSize : i*partSize+partSize]
+        }
+
+        var wg sync.WaitGroup
+        var mu sync.Mutex
+        errCh := make(chan error, opts.NumThreads)
+
+        reader = newHook(reader, opts.Progress)
+
+        // Part number always starts with '1'.
+        var partNumber int
+        for partNumber = 1; partNumber <= totalPartsCount; partNumber++ {
+                // Proceed to upload the part.
+                var buf []byte
+                select {
+                case buf = <-bufs:
+                case err = <-errCh:
+                        cancel()
+                        wg.Wait()
+                        return UploadInfo{}, err
+                }
+
+                if int64(len(buf)) != partSize {
+                        return UploadInfo{}, fmt.Errorf("read buffer < %d than expected partSize: %d", len(buf), partSize)
+                }
+
+                length, rerr := readFull(reader, buf)
+                if rerr == io.EOF && partNumber > 1 {
+                        // Done
+                        break
+                }
+
+                if rerr != nil && rerr != io.ErrUnexpectedEOF && err != io.EOF {
+                        cancel()
+                        wg.Wait()
+                        return UploadInfo{}, rerr
+                }
+
+                // Calculate md5sum.
+                customHeader := make(http.Header)
+                if !opts.SendContentMd5 {
+                        // Add CRC32C instead.
+                        crc.Reset()
+                        crc.Write(buf[:length])
+                        cSum := crc.Sum(nil)
+                        customHeader.Set("x-amz-checksum-crc32c", base64.StdEncoding.EncodeToString(cSum))
+                        crcBytes = append(crcBytes, cSum...)
+                }
+
+                wg.Add(1)
+                go func(partNumber int) {
+                        // Avoid declaring variables in the for loop
+                        var md5Base64 string
+
+                        if opts.SendContentMd5 {
+                                md5Hash := c.md5Hasher()
+                                md5Hash.Write(buf[:length])
+                                md5Base64 = base64.StdEncoding.EncodeToString(md5Hash.Sum(nil))
+                                md5Hash.Close()
+                        }
+
+                        defer wg.Done()
+                        p := uploadPartParams{
+                                bucketName:   bucketName,
+                                objectName:   objectName,
+                                uploadID:     uploadID,
+                                reader:       bytes.NewReader(buf[:length]),
+                                partNumber:   partNumber,
+                                md5Base64:    md5Base64,
+                                size:         int64(length),
+                                sse:          opts.ServerSideEncryption,
+                                streamSha256: !opts.DisableContentSha256,
+                                customHeader: customHeader,
+                        }
+                        objPart, uerr := c.uploadPart(ctx, p)
+                        if uerr != nil {
+                                errCh <- uerr
+                                return
+                        }
+
+                        // Save successfully uploaded part metadata.
+                        mu.Lock()
+                        partsInfo[partNumber] = objPart
+                        mu.Unlock()
+
+                        // Send buffer back so it can be reused.
+                        bufs <- buf
+                }(partNumber)
+
+                // Save successfully uploaded size.
+                totalUploadedSize += int64(length)
+        }
+        wg.Wait()
+
+        // Collect any error
+        select {
+        case err = <-errCh:
+                return UploadInfo{}, err
+        default:
+        }
+
+        // Complete multipart upload.
+        var complMultipartUpload completeMultipartUpload
+
+        // Loop over total uploaded parts to save them in
+        // Parts array before completing the multipart request.
+        for i := 1; i < partNumber; i++ {
+                part, ok := partsInfo[i]
+                if !ok {
+                        return UploadInfo{}, errInvalidArgument(fmt.Sprintf("Missing part number %d", i))
+                }
+                complMultipartUpload.Parts = append(complMultipartUpload.Parts, CompletePart{
+                        ETag:           part.ETag,
+                        PartNumber:     part.PartNumber,
+                        ChecksumCRC32:  part.ChecksumCRC32,
+                        ChecksumCRC32C: part.ChecksumCRC32C,
+                        ChecksumSHA1:   part.ChecksumSHA1,
+                        ChecksumSHA256: part.ChecksumSHA256,
+                })
+        }
+
+        // Sort all completed parts.
+        sort.Sort(completedParts(complMultipartUpload.Parts))
+
+        opts = PutObjectOptions{}
+        if len(crcBytes) > 0 {
+                // Add hash of hashes.
+                crc.Reset()
+                crc.Write(crcBytes)
+                opts.UserMetadata = map[string]string{"X-Amz-Checksum-Crc32c": base64.StdEncoding.EncodeToString(crc.Sum(nil))}
+        }
+        uploadInfo, err := c.completeMultipartUpload(ctx, bucketName, objectName, uploadID, complMultipartUpload, opts)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+
+        uploadInfo.Size = totalUploadedSize
+        return uploadInfo, nil
+}
+
+// putObject special function used Google Cloud Storage. This special function
+// is used for Google Cloud Storage since Google's multipart API is not S3 compatible.
+func (c *Client) putObject(ctx context.Context, bucketName, objectName string, reader io.Reader, size int64, opts PutObjectOptions) (info UploadInfo, err error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return UploadInfo{}, err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return UploadInfo{}, err
+        }
+
+        // Size -1 is only supported on Google Cloud Storage, we error
+        // out in all other situations.
+        if size < 0 && !s3utils.IsGoogleEndpoint(*c.endpointURL) {
+                return UploadInfo{}, errEntityTooSmall(size, bucketName, objectName)
+        }
+
+        if opts.SendContentMd5 && s3utils.IsGoogleEndpoint(*c.endpointURL) && size < 0 {
+                return UploadInfo{}, errInvalidArgument("MD5Sum cannot be calculated with size '-1'")
+        }
+
+        var readSeeker io.Seeker
+        if size > 0 {
+                if isReadAt(reader) && !isObject(reader) {
+                        seeker, ok := reader.(io.Seeker)
+                        if ok {
+                                offset, err := seeker.Seek(0, io.SeekCurrent)
+                                if err != nil {
+                                        return UploadInfo{}, errInvalidArgument(err.Error())
+                                }
+                                reader = io.NewSectionReader(reader.(io.ReaderAt), offset, size)
+                                readSeeker = reader.(io.Seeker)
+                        }
+                }
+        }
+
+        var md5Base64 string
+        if opts.SendContentMd5 {
+                // Calculate md5sum.
+                hash := c.md5Hasher()
+
+                if readSeeker != nil {
+                        if _, err := io.Copy(hash, reader); err != nil {
+                                return UploadInfo{}, err
+                        }
+                        // Seek back to beginning of io.NewSectionReader's offset.
+                        _, err = readSeeker.Seek(0, io.SeekStart)
+                        if err != nil {
+                                return UploadInfo{}, errInvalidArgument(err.Error())
+                        }
+                } else {
+                        // Create a buffer.
+                        buf := make([]byte, size)
+
+                        length, err := readFull(reader, buf)
+                        if err != nil && err != io.ErrUnexpectedEOF && err != io.EOF {
+                                return UploadInfo{}, err
+                        }
+
+                        hash.Write(buf[:length])
+                        reader = bytes.NewReader(buf[:length])
+                }
+
+                md5Base64 = base64.StdEncoding.EncodeToString(hash.Sum(nil))
+                hash.Close()
+        }
+
+        // Update progress reader appropriately to the latest offset as we
+        // read from the source.
+        progressReader := newHook(reader, opts.Progress)
+
+        // This function does not calculate sha256 and md5sum for payload.
+        // Execute put object.
+        return c.putObjectDo(ctx, bucketName, objectName, progressReader, md5Base64, "", size, opts)
+}
+
+// putObjectDo - executes the put object http operation.
+// NOTE: You must have WRITE permissions on a bucket to add an object to it.
+func (c *Client) putObjectDo(ctx context.Context, bucketName, objectName string, reader io.Reader, md5Base64, sha256Hex string, size int64, opts PutObjectOptions) (UploadInfo, error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return UploadInfo{}, err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return UploadInfo{}, err
+        }
+        // Set headers.
+        customHeader := opts.Header()
+
+        // Add CRC when client supports it, MD5 is not set, not Google and we don't add SHA256 to chunks.
+        addCrc := c.trailingHeaderSupport && md5Base64 == "" && !s3utils.IsGoogleEndpoint(*c.endpointURL) && (opts.DisableContentSha256 || c.secure)
+
+        if addCrc {
+                // If user has added checksums, don't add them ourselves.
+                for k := range opts.UserMetadata {
+                        if strings.HasPrefix(strings.ToLower(k), "x-amz-checksum-") {
+                                addCrc = false
+                        }
+                }
+        }
+        // Populate request metadata.
+        reqMetadata := requestMetadata{
+                bucketName:       bucketName,
+                objectName:       objectName,
+                customHeader:     customHeader,
+                contentBody:      reader,
+                contentLength:    size,
+                contentMD5Base64: md5Base64,
+                contentSHA256Hex: sha256Hex,
+                streamSha256:     !opts.DisableContentSha256,
+                addCrc:           addCrc,
+        }
+        if opts.Internal.SourceVersionID != "" {
+                if opts.Internal.SourceVersionID != nullVersionID {
+                        if _, err := uuid.Parse(opts.Internal.SourceVersionID); err != nil {
+                                return UploadInfo{}, errInvalidArgument(err.Error())
+                        }
+                }
+                urlValues := make(url.Values)
+                urlValues.Set("versionId", opts.Internal.SourceVersionID)
+                reqMetadata.queryValues = urlValues
+        }
+
+        // Execute PUT an objectName.
+        resp, err := c.executeMethod(ctx, http.MethodPut, reqMetadata)
+        defer closeResponse(resp)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        return UploadInfo{}, httpRespToErrorResponse(resp, bucketName, objectName)
+                }
+        }
+
+        // extract lifecycle expiry date and rule ID
+        expTime, ruleID := amzExpirationToExpiryDateRuleID(resp.Header.Get(amzExpiration))
+        h := resp.Header
+        return UploadInfo{
+                Bucket:           bucketName,
+                Key:              objectName,
+                ETag:             trimEtag(h.Get("ETag")),
+                VersionID:        h.Get(amzVersionID),
+                Size:             size,
+                Expiration:       expTime,
+                ExpirationRuleID: ruleID,
+
+                // Checksum values
+                ChecksumCRC32:  h.Get("x-amz-checksum-crc32"),
+                ChecksumCRC32C: h.Get("x-amz-checksum-crc32c"),
+                ChecksumSHA1:   h.Get("x-amz-checksum-sha1"),
+                ChecksumSHA256: h.Get("x-amz-checksum-sha256"),
+        }, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-put-object.go b/vendor/github.com/minio/minio-go/v7/api-put-object.go
new file mode 100644
index 0000000..bbd8924
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-put-object.go
@@ -0,0 +1,473 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/base64"
+        "errors"
+        "fmt"
+        "hash/crc32"
+        "io"
+        "net/http"
+        "sort"
+        "time"
+
+        "github.com/minio/minio-go/v7/pkg/encrypt"
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+        "golang.org/x/net/http/httpguts"
+)
+
+// ReplicationStatus represents replication status of object
+type ReplicationStatus string
+
+const (
+        // ReplicationStatusPending indicates replication is pending
+        ReplicationStatusPending ReplicationStatus = "PENDING"
+        // ReplicationStatusComplete indicates replication completed ok
+        ReplicationStatusComplete ReplicationStatus = "COMPLETED"
+        // ReplicationStatusFailed indicates replication failed
+        ReplicationStatusFailed ReplicationStatus = "FAILED"
+        // ReplicationStatusReplica indicates object is a replica of a source
+        ReplicationStatusReplica ReplicationStatus = "REPLICA"
+)
+
+// Empty returns true if no replication status set.
+func (r ReplicationStatus) Empty() bool {
+        return r == ""
+}
+
+// AdvancedPutOptions for internal use - to be utilized by replication, ILM transition
+// implementation on MinIO server
+type AdvancedPutOptions struct {
+        SourceVersionID          string
+        SourceETag               string
+        ReplicationStatus        ReplicationStatus
+        SourceMTime              time.Time
+        ReplicationRequest       bool
+        RetentionTimestamp       time.Time
+        TaggingTimestamp         time.Time
+        LegalholdTimestamp       time.Time
+        ReplicationValidityCheck bool
+}
+
+// PutObjectOptions represents options specified by user for PutObject call
+type PutObjectOptions struct {
+        UserMetadata            map[string]string
+        UserTags                map[string]string
+        Progress                io.Reader
+        ContentType             string
+        ContentEncoding         string
+        ContentDisposition      string
+        ContentLanguage         string
+        CacheControl            string
+        Expires                 time.Time
+        Mode                    RetentionMode
+        RetainUntilDate         time.Time
+        ServerSideEncryption    encrypt.ServerSide
+        NumThreads              uint
+        StorageClass            string
+        WebsiteRedirectLocation string
+        PartSize                uint64
+        LegalHold               LegalHoldStatus
+        SendContentMd5          bool
+        DisableContentSha256    bool
+        DisableMultipart        bool
+
+        // ConcurrentStreamParts will create NumThreads buffers of PartSize bytes,
+        // fill them serially and upload them in parallel.
+        // This can be used for faster uploads on non-seekable or slow-to-seek input.
+        ConcurrentStreamParts bool
+        Internal              AdvancedPutOptions
+
+        customHeaders http.Header
+}
+
+// SetMatchETag if etag matches while PUT MinIO returns an error
+// this is a MinIO specific extension to support optimistic locking
+// semantics.
+func (opts *PutObjectOptions) SetMatchETag(etag string) {
+        if opts.customHeaders == nil {
+                opts.customHeaders = http.Header{}
+        }
+        opts.customHeaders.Set("If-Match", "\""+etag+"\"")
+}
+
+// SetMatchETagExcept if etag does not match while PUT MinIO returns an
+// error this is a MinIO specific extension to support optimistic locking
+// semantics.
+func (opts *PutObjectOptions) SetMatchETagExcept(etag string) {
+        if opts.customHeaders == nil {
+                opts.customHeaders = http.Header{}
+        }
+        opts.customHeaders.Set("If-None-Match", "\""+etag+"\"")
+}
+
+// getNumThreads - gets the number of threads to be used in the multipart
+// put object operation
+func (opts PutObjectOptions) getNumThreads() (numThreads int) {
+        if opts.NumThreads > 0 {
+                numThreads = int(opts.NumThreads)
+        } else {
+                numThreads = totalWorkers
+        }
+        return
+}
+
+// Header - constructs the headers from metadata entered by user in
+// PutObjectOptions struct
+func (opts PutObjectOptions) Header() (header http.Header) {
+        header = make(http.Header)
+
+        contentType := opts.ContentType
+        if contentType == "" {
+                contentType = "application/octet-stream"
+        }
+        header.Set("Content-Type", contentType)
+
+        if opts.ContentEncoding != "" {
+                header.Set("Content-Encoding", opts.ContentEncoding)
+        }
+        if opts.ContentDisposition != "" {
+                header.Set("Content-Disposition", opts.ContentDisposition)
+        }
+        if opts.ContentLanguage != "" {
+                header.Set("Content-Language", opts.ContentLanguage)
+        }
+        if opts.CacheControl != "" {
+                header.Set("Cache-Control", opts.CacheControl)
+        }
+
+        if !opts.Expires.IsZero() {
+                header.Set("Expires", opts.Expires.UTC().Format(http.TimeFormat))
+        }
+
+        if opts.Mode != "" {
+                header.Set(amzLockMode, opts.Mode.String())
+        }
+
+        if !opts.RetainUntilDate.IsZero() {
+                header.Set("X-Amz-Object-Lock-Retain-Until-Date", opts.RetainUntilDate.Format(time.RFC3339))
+        }
+
+        if opts.LegalHold != "" {
+                header.Set(amzLegalHoldHeader, opts.LegalHold.String())
+        }
+
+        if opts.ServerSideEncryption != nil {
+                opts.ServerSideEncryption.Marshal(header)
+        }
+
+        if opts.StorageClass != "" {
+                header.Set(amzStorageClass, opts.StorageClass)
+        }
+
+        if opts.WebsiteRedirectLocation != "" {
+                header.Set(amzWebsiteRedirectLocation, opts.WebsiteRedirectLocation)
+        }
+
+        if !opts.Internal.ReplicationStatus.Empty() {
+                header.Set(amzBucketReplicationStatus, string(opts.Internal.ReplicationStatus))
+        }
+        if !opts.Internal.SourceMTime.IsZero() {
+                header.Set(minIOBucketSourceMTime, opts.Internal.SourceMTime.Format(time.RFC3339Nano))
+        }
+        if opts.Internal.SourceETag != "" {
+                header.Set(minIOBucketSourceETag, opts.Internal.SourceETag)
+        }
+        if opts.Internal.ReplicationRequest {
+                header.Set(minIOBucketReplicationRequest, "true")
+        }
+        if opts.Internal.ReplicationValidityCheck {
+                header.Set(minIOBucketReplicationCheck, "true")
+        }
+        if !opts.Internal.LegalholdTimestamp.IsZero() {
+                header.Set(minIOBucketReplicationObjectLegalHoldTimestamp, opts.Internal.LegalholdTimestamp.Format(time.RFC3339Nano))
+        }
+        if !opts.Internal.RetentionTimestamp.IsZero() {
+                header.Set(minIOBucketReplicationObjectRetentionTimestamp, opts.Internal.RetentionTimestamp.Format(time.RFC3339Nano))
+        }
+        if !opts.Internal.TaggingTimestamp.IsZero() {
+                header.Set(minIOBucketReplicationTaggingTimestamp, opts.Internal.TaggingTimestamp.Format(time.RFC3339Nano))
+        }
+
+        if len(opts.UserTags) != 0 {
+                header.Set(amzTaggingHeader, s3utils.TagEncode(opts.UserTags))
+        }
+
+        for k, v := range opts.UserMetadata {
+                if isAmzHeader(k) || isStandardHeader(k) || isStorageClassHeader(k) {
+                        header.Set(k, v)
+                } else {
+                        header.Set("x-amz-meta-"+k, v)
+                }
+        }
+
+        // set any other additional custom headers.
+        for k, v := range opts.customHeaders {
+                header[k] = v
+        }
+
+        return
+}
+
+// validate() checks if the UserMetadata map has standard headers or and raises an error if so.
+func (opts PutObjectOptions) validate() (err error) {
+        for k, v := range opts.UserMetadata {
+                if !httpguts.ValidHeaderFieldName(k) || isStandardHeader(k) || isSSEHeader(k) || isStorageClassHeader(k) {
+                        return errInvalidArgument(k + " unsupported user defined metadata name")
+                }
+                if !httpguts.ValidHeaderFieldValue(v) {
+                        return errInvalidArgument(v + " unsupported user defined metadata value")
+                }
+        }
+        if opts.Mode != "" && !opts.Mode.IsValid() {
+                return errInvalidArgument(opts.Mode.String() + " unsupported retention mode")
+        }
+        if opts.LegalHold != "" && !opts.LegalHold.IsValid() {
+                return errInvalidArgument(opts.LegalHold.String() + " unsupported legal-hold status")
+        }
+        return nil
+}
+
+// completedParts is a collection of parts sortable by their part numbers.
+// used for sorting the uploaded parts before completing the multipart request.
+type completedParts []CompletePart
+
+func (a completedParts) Len() int           { return len(a) }
+func (a completedParts) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a completedParts) Less(i, j int) bool { return a[i].PartNumber < a[j].PartNumber }
+
+// PutObject creates an object in a bucket.
+//
+// You must have WRITE permissions on a bucket to create an object.
+//
+//   - For size smaller than 16MiB PutObject automatically does a
+//     single atomic PUT operation.
+//
+//   - For size larger than 16MiB PutObject automatically does a
+//     multipart upload operation.
+//
+//   - For size input as -1 PutObject does a multipart Put operation
+//     until input stream reaches EOF. Maximum object size that can
+//     be uploaded through this operation will be 5TiB.
+//
+//     WARNING: Passing down '-1' will use memory and these cannot
+//     be reused for best outcomes for PutObject(), pass the size always.
+//
+// NOTE: Upon errors during upload multipart operation is entirely aborted.
+func (c *Client) PutObject(ctx context.Context, bucketName, objectName string, reader io.Reader, objectSize int64,
+        opts PutObjectOptions,
+) (info UploadInfo, err error) {
+        if objectSize < 0 && opts.DisableMultipart {
+                return UploadInfo{}, errors.New("object size must be provided with disable multipart upload")
+        }
+
+        err = opts.validate()
+        if err != nil {
+                return UploadInfo{}, err
+        }
+
+        return c.putObjectCommon(ctx, bucketName, objectName, reader, objectSize, opts)
+}
+
+func (c *Client) putObjectCommon(ctx context.Context, bucketName, objectName string, reader io.Reader, size int64, opts PutObjectOptions) (info UploadInfo, err error) {
+        // Check for largest object size allowed.
+        if size > int64(maxMultipartPutObjectSize) {
+                return UploadInfo{}, errEntityTooLarge(size, maxMultipartPutObjectSize, bucketName, objectName)
+        }
+
+        // NOTE: Streaming signature is not supported by GCS.
+        if s3utils.IsGoogleEndpoint(*c.endpointURL) {
+                return c.putObject(ctx, bucketName, objectName, reader, size, opts)
+        }
+
+        partSize := opts.PartSize
+        if opts.PartSize == 0 {
+                partSize = minPartSize
+        }
+
+        if c.overrideSignerType.IsV2() {
+                if size >= 0 && size < int64(partSize) || opts.DisableMultipart {
+                        return c.putObject(ctx, bucketName, objectName, reader, size, opts)
+                }
+                return c.putObjectMultipart(ctx, bucketName, objectName, reader, size, opts)
+        }
+
+        if size < 0 {
+                if opts.DisableMultipart {
+                        return UploadInfo{}, errors.New("no length provided and multipart disabled")
+                }
+                if opts.ConcurrentStreamParts && opts.NumThreads > 1 {
+                        return c.putObjectMultipartStreamParallel(ctx, bucketName, objectName, reader, opts)
+                }
+                return c.putObjectMultipartStreamNoLength(ctx, bucketName, objectName, reader, opts)
+        }
+
+        if size < int64(partSize) || opts.DisableMultipart {
+                return c.putObject(ctx, bucketName, objectName, reader, size, opts)
+        }
+
+        return c.putObjectMultipartStream(ctx, bucketName, objectName, reader, size, opts)
+}
+
+func (c *Client) putObjectMultipartStreamNoLength(ctx context.Context, bucketName, objectName string, reader io.Reader, opts PutObjectOptions) (info UploadInfo, err error) {
+        // Input validation.
+        if err = s3utils.CheckValidBucketName(bucketName); err != nil {
+                return UploadInfo{}, err
+        }
+        if err = s3utils.CheckValidObjectName(objectName); err != nil {
+                return UploadInfo{}, err
+        }
+
+        // Total data read and written to server. should be equal to
+        // 'size' at the end of the call.
+        var totalUploadedSize int64
+
+        // Complete multipart upload.
+        var complMultipartUpload completeMultipartUpload
+
+        // Calculate the optimal parts info for a given size.
+        totalPartsCount, partSize, _, err := OptimalPartInfo(-1, opts.PartSize)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+
+        if !opts.SendContentMd5 {
+                if opts.UserMetadata == nil {
+                        opts.UserMetadata = make(map[string]string, 1)
+                }
+                opts.UserMetadata["X-Amz-Checksum-Algorithm"] = "CRC32C"
+        }
+
+        // Initiate a new multipart upload.
+        uploadID, err := c.newUploadID(ctx, bucketName, objectName, opts)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+        delete(opts.UserMetadata, "X-Amz-Checksum-Algorithm")
+
+        defer func() {
+                if err != nil {
+                        c.abortMultipartUpload(ctx, bucketName, objectName, uploadID)
+                }
+        }()
+
+        // Part number always starts with '1'.
+        partNumber := 1
+
+        // Initialize parts uploaded map.
+        partsInfo := make(map[int]ObjectPart)
+
+        // Create a buffer.
+        buf := make([]byte, partSize)
+
+        // Create checksums
+        // CRC32C is ~50% faster on AMD64 @ 30GB/s
+        var crcBytes []byte
+        customHeader := make(http.Header)
+        crc := crc32.New(crc32.MakeTable(crc32.Castagnoli))
+
+        for partNumber <= totalPartsCount {
+                length, rerr := readFull(reader, buf)
+                if rerr == io.EOF && partNumber > 1 {
+                        break
+                }
+
+                if rerr != nil && rerr != io.ErrUnexpectedEOF && rerr != io.EOF {
+                        return UploadInfo{}, rerr
+                }
+
+                var md5Base64 string
+                if opts.SendContentMd5 {
+                        // Calculate md5sum.
+                        hash := c.md5Hasher()
+                        hash.Write(buf[:length])
+                        md5Base64 = base64.StdEncoding.EncodeToString(hash.Sum(nil))
+                        hash.Close()
+                } else {
+                        crc.Reset()
+                        crc.Write(buf[:length])
+                        cSum := crc.Sum(nil)
+                        customHeader.Set("x-amz-checksum-crc32c", base64.StdEncoding.EncodeToString(cSum))
+                        crcBytes = append(crcBytes, cSum...)
+                }
+
+                // Update progress reader appropriately to the latest offset
+                // as we read from the source.
+                rd := newHook(bytes.NewReader(buf[:length]), opts.Progress)
+
+                // Proceed to upload the part.
+                p := uploadPartParams{bucketName: bucketName, objectName: objectName, uploadID: uploadID, reader: rd, partNumber: partNumber, md5Base64: md5Base64, size: int64(length), sse: opts.ServerSideEncryption, streamSha256: !opts.DisableContentSha256, customHeader: customHeader}
+                objPart, uerr := c.uploadPart(ctx, p)
+                if uerr != nil {
+                        return UploadInfo{}, uerr
+                }
+
+                // Save successfully uploaded part metadata.
+                partsInfo[partNumber] = objPart
+
+                // Save successfully uploaded size.
+                totalUploadedSize += int64(length)
+
+                // Increment part number.
+                partNumber++
+
+                // For unknown size, Read EOF we break away.
+                // We do not have to upload till totalPartsCount.
+                if rerr == io.EOF {
+                        break
+                }
+        }
+
+        // Loop over total uploaded parts to save them in
+        // Parts array before completing the multipart request.
+        for i := 1; i < partNumber; i++ {
+                part, ok := partsInfo[i]
+                if !ok {
+                        return UploadInfo{}, errInvalidArgument(fmt.Sprintf("Missing part number %d", i))
+                }
+                complMultipartUpload.Parts = append(complMultipartUpload.Parts, CompletePart{
+                        ETag:           part.ETag,
+                        PartNumber:     part.PartNumber,
+                        ChecksumCRC32:  part.ChecksumCRC32,
+                        ChecksumCRC32C: part.ChecksumCRC32C,
+                        ChecksumSHA1:   part.ChecksumSHA1,
+                        ChecksumSHA256: part.ChecksumSHA256,
+                })
+        }
+
+        // Sort all completed parts.
+        sort.Sort(completedParts(complMultipartUpload.Parts))
+
+        opts = PutObjectOptions{}
+        if len(crcBytes) > 0 {
+                // Add hash of hashes.
+                crc.Reset()
+                crc.Write(crcBytes)
+                opts.UserMetadata = map[string]string{"X-Amz-Checksum-Crc32c": base64.StdEncoding.EncodeToString(crc.Sum(nil))}
+        }
+        uploadInfo, err := c.completeMultipartUpload(ctx, bucketName, objectName, uploadID, complMultipartUpload, opts)
+        if err != nil {
+                return UploadInfo{}, err
+        }
+
+        uploadInfo.Size = totalUploadedSize
+        return uploadInfo, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-putobject-snowball.go b/vendor/github.com/minio/minio-go/v7/api-putobject-snowball.go
new file mode 100644
index 0000000..eb4da41
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-putobject-snowball.go
@@ -0,0 +1,246 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2021 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 minio
+
+import (
+        "archive/tar"
+        "bufio"
+        "bytes"
+        "context"
+        "fmt"
+        "io"
+        "net/http"
+        "os"
+        "strings"
+        "sync"
+        "time"
+
+        "github.com/klauspost/compress/s2"
+)
+
+// SnowballOptions contains options for PutObjectsSnowball calls.
+type SnowballOptions struct {
+        // Opts is options applied to all objects.
+        Opts PutObjectOptions
+
+        // Processing options:
+
+        // InMemory specifies that all objects should be collected in memory
+        // before they are uploaded.
+        // If false a temporary file will be created.
+        InMemory bool
+
+        // Compress enabled content compression before upload.
+        // Compression will typically reduce memory and network usage,
+        // Compression can safely be enabled with MinIO hosts.
+        Compress bool
+
+        // SkipErrs if enabled will skip any errors while reading the
+        // object content while creating the snowball archive
+        SkipErrs bool
+}
+
+// SnowballObject contains information about a single object to be added to the snowball.
+type SnowballObject struct {
+        // Key is the destination key, including prefix.
+        Key string
+
+        // Size is the content size of this object.
+        Size int64
+
+        // Modtime to apply to the object.
+        // If Modtime is the zero value current time will be used.
+        ModTime time.Time
+
+        // Content of the object.
+        // Exactly 'Size' number of bytes must be provided.
+        Content io.Reader
+
+        // VersionID of the object; if empty, a new versionID will be generated
+        VersionID string
+
+        // Headers contains more options for this object upload, the same as you
+        // would include in a regular PutObject operation, such as user metadata
+        // and content-disposition, expires, ..
+        Headers http.Header
+
+        // Close will be called when an object has finished processing.
+        // Note that if PutObjectsSnowball returns because of an error,
+        // objects not consumed from the input will NOT have been closed.
+        // Leave as nil for no callback.
+        Close func()
+}
+
+type nopReadSeekCloser struct {
+        io.ReadSeeker
+}
+
+func (n nopReadSeekCloser) Close() error {
+        return nil
+}
+
+// This is available as io.ReadSeekCloser from go1.16
+type readSeekCloser interface {
+        io.Reader
+        io.Closer
+        io.Seeker
+}
+
+// PutObjectsSnowball will put multiple objects with a single put call.
+// A (compressed) TAR file will be created which will contain multiple objects.
+// The key for each object will be used for the destination in the specified bucket.
+// Total size should be < 5TB.
+// This function blocks until 'objs' is closed and the content has been uploaded.
+func (c Client) PutObjectsSnowball(ctx context.Context, bucketName string, opts SnowballOptions, objs <-chan SnowballObject) (err error) {
+        err = opts.Opts.validate()
+        if err != nil {
+                return err
+        }
+        var tmpWriter io.Writer
+        var getTmpReader func() (rc readSeekCloser, sz int64, err error)
+        if opts.InMemory {
+                b := bytes.NewBuffer(nil)
+                tmpWriter = b
+                getTmpReader = func() (readSeekCloser, int64, error) {
+                        return nopReadSeekCloser{bytes.NewReader(b.Bytes())}, int64(b.Len()), nil
+                }
+        } else {
+                f, err := os.CreateTemp("", "s3-putsnowballobjects-*")
+                if err != nil {
+                        return err
+                }
+                name := f.Name()
+                tmpWriter = f
+                var once sync.Once
+                defer once.Do(func() {
+                        f.Close()
+                })
+                defer os.Remove(name)
+                getTmpReader = func() (readSeekCloser, int64, error) {
+                        once.Do(func() {
+                                f.Close()
+                        })
+                        f, err := os.Open(name)
+                        if err != nil {
+                                return nil, 0, err
+                        }
+                        st, err := f.Stat()
+                        if err != nil {
+                                return nil, 0, err
+                        }
+                        return f, st.Size(), nil
+                }
+        }
+        flush := func() error { return nil }
+        if !opts.Compress {
+                if !opts.InMemory {
+                        // Insert buffer for writes.
+                        buf := bufio.NewWriterSize(tmpWriter, 1<<20)
+                        flush = buf.Flush
+                        tmpWriter = buf
+                }
+        } else {
+                s2c := s2.NewWriter(tmpWriter, s2.WriterBetterCompression())
+                flush = s2c.Close
+                defer s2c.Close()
+                tmpWriter = s2c
+        }
+        t := tar.NewWriter(tmpWriter)
+
+objectLoop:
+        for {
+                select {
+                case <-ctx.Done():
+                        return ctx.Err()
+                case obj, ok := <-objs:
+                        if !ok {
+                                break objectLoop
+                        }
+
+                        closeObj := func() {}
+                        if obj.Close != nil {
+                                closeObj = obj.Close
+                        }
+
+                        // Trim accidental slash prefix.
+                        obj.Key = strings.TrimPrefix(obj.Key, "/")
+                        header := tar.Header{
+                                Typeflag: tar.TypeReg,
+                                Name:     obj.Key,
+                                Size:     obj.Size,
+                                ModTime:  obj.ModTime,
+                                Format:   tar.FormatPAX,
+                        }
+                        if header.ModTime.IsZero() {
+                                header.ModTime = time.Now().UTC()
+                        }
+
+                        header.PAXRecords = make(map[string]string)
+                        if obj.VersionID != "" {
+                                header.PAXRecords["minio.versionId"] = obj.VersionID
+                        }
+                        for k, vals := range obj.Headers {
+                                header.PAXRecords["minio.metadata."+k] = strings.Join(vals, ",")
+                        }
+
+                        if err := t.WriteHeader(&header); err != nil {
+                                closeObj()
+                                return err
+                        }
+                        n, err := io.Copy(t, obj.Content)
+                        if err != nil {
+                                closeObj()
+                                if opts.SkipErrs {
+                                        continue
+                                }
+                                return err
+                        }
+                        if n != obj.Size {
+                                closeObj()
+                                if opts.SkipErrs {
+                                        continue
+                                }
+                                return io.ErrUnexpectedEOF
+                        }
+                        closeObj()
+                }
+        }
+        // Flush tar
+        err = t.Flush()
+        if err != nil {
+                return err
+        }
+        // Flush compression
+        err = flush()
+        if err != nil {
+                return err
+        }
+        if opts.Opts.UserMetadata == nil {
+                opts.Opts.UserMetadata = map[string]string{}
+        }
+        opts.Opts.UserMetadata["X-Amz-Meta-Snowball-Auto-Extract"] = "true"
+        opts.Opts.DisableMultipart = true
+        rc, sz, err := getTmpReader()
+        if err != nil {
+                return err
+        }
+        defer rc.Close()
+        rand := c.random.Uint64()
+        _, err = c.PutObject(ctx, bucketName, fmt.Sprintf("snowball-upload-%x.tar", rand), rc, sz, opts.Opts)
+        return err
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-remove.go b/vendor/github.com/minio/minio-go/v7/api-remove.go
new file mode 100644
index 0000000..9c0ac44
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-remove.go
@@ -0,0 +1,548 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2020 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/xml"
+        "io"
+        "net/http"
+        "net/url"
+        "time"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+//revive:disable
+
+// Deprecated: BucketOptions will be renamed to RemoveBucketOptions in future versions.
+type BucketOptions = RemoveBucketOptions
+
+//revive:enable
+
+// RemoveBucketOptions special headers to purge buckets, only
+// useful when endpoint is MinIO
+type RemoveBucketOptions struct {
+        ForceDelete bool
+}
+
+// RemoveBucketWithOptions deletes the bucket name.
+//
+// All objects (including all object versions and delete markers)
+// in the bucket will be deleted forcibly if bucket options set
+// ForceDelete to 'true'.
+func (c *Client) RemoveBucketWithOptions(ctx context.Context, bucketName string, opts RemoveBucketOptions) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+
+        // Build headers.
+        headers := make(http.Header)
+        if opts.ForceDelete {
+                headers.Set(minIOForceDelete, "true")
+        }
+
+        // Execute DELETE on bucket.
+        resp, err := c.executeMethod(ctx, http.MethodDelete, requestMetadata{
+                bucketName:       bucketName,
+                contentSHA256Hex: emptySHA256Hex,
+                customHeader:     headers,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusNoContent {
+                        return httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+
+        // Remove the location from cache on a successful delete.
+        c.bucketLocCache.Delete(bucketName)
+        return nil
+}
+
+// RemoveBucket deletes the bucket name.
+//
+//      All objects (including all object versions and delete markers).
+//      in the bucket must be deleted before successfully attempting this request.
+func (c *Client) RemoveBucket(ctx context.Context, bucketName string) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+        // Execute DELETE on bucket.
+        resp, err := c.executeMethod(ctx, http.MethodDelete, requestMetadata{
+                bucketName:       bucketName,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusNoContent {
+                        return httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+
+        // Remove the location from cache on a successful delete.
+        c.bucketLocCache.Delete(bucketName)
+
+        return nil
+}
+
+// AdvancedRemoveOptions intended for internal use by replication
+type AdvancedRemoveOptions struct {
+        ReplicationDeleteMarker  bool
+        ReplicationStatus        ReplicationStatus
+        ReplicationMTime         time.Time
+        ReplicationRequest       bool
+        ReplicationValidityCheck bool // check permissions
+}
+
+// RemoveObjectOptions represents options specified by user for RemoveObject call
+type RemoveObjectOptions struct {
+        ForceDelete      bool
+        GovernanceBypass bool
+        VersionID        string
+        Internal         AdvancedRemoveOptions
+}
+
+// RemoveObject removes an object from a bucket.
+func (c *Client) RemoveObject(ctx context.Context, bucketName, objectName string, opts RemoveObjectOptions) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return err
+        }
+
+        res := c.removeObject(ctx, bucketName, objectName, opts)
+        return res.Err
+}
+
+func (c *Client) removeObject(ctx context.Context, bucketName, objectName string, opts RemoveObjectOptions) RemoveObjectResult {
+        // Get resources properly escaped and lined up before
+        // using them in http request.
+        urlValues := make(url.Values)
+
+        if opts.VersionID != "" {
+                urlValues.Set("versionId", opts.VersionID)
+        }
+
+        // Build headers.
+        headers := make(http.Header)
+
+        if opts.GovernanceBypass {
+                // Set the bypass goverenance retention header
+                headers.Set(amzBypassGovernance, "true")
+        }
+        if opts.Internal.ReplicationDeleteMarker {
+                headers.Set(minIOBucketReplicationDeleteMarker, "true")
+        }
+        if !opts.Internal.ReplicationMTime.IsZero() {
+                headers.Set(minIOBucketSourceMTime, opts.Internal.ReplicationMTime.Format(time.RFC3339Nano))
+        }
+        if !opts.Internal.ReplicationStatus.Empty() {
+                headers.Set(amzBucketReplicationStatus, string(opts.Internal.ReplicationStatus))
+        }
+        if opts.Internal.ReplicationRequest {
+                headers.Set(minIOBucketReplicationRequest, "true")
+        }
+        if opts.Internal.ReplicationValidityCheck {
+                headers.Set(minIOBucketReplicationCheck, "true")
+        }
+        if opts.ForceDelete {
+                headers.Set(minIOForceDelete, "true")
+        }
+        // Execute DELETE on objectName.
+        resp, err := c.executeMethod(ctx, http.MethodDelete, requestMetadata{
+                bucketName:       bucketName,
+                objectName:       objectName,
+                contentSHA256Hex: emptySHA256Hex,
+                queryValues:      urlValues,
+                customHeader:     headers,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return RemoveObjectResult{Err: err}
+        }
+        if resp != nil {
+                // if some unexpected error happened and max retry is reached, we want to let client know
+                if resp.StatusCode != http.StatusNoContent {
+                        err := httpRespToErrorResponse(resp, bucketName, objectName)
+                        return RemoveObjectResult{Err: err}
+                }
+        }
+
+        // DeleteObject always responds with http '204' even for
+        // objects which do not exist. So no need to handle them
+        // specifically.
+        return RemoveObjectResult{
+                ObjectName:            objectName,
+                ObjectVersionID:       opts.VersionID,
+                DeleteMarker:          resp.Header.Get("x-amz-delete-marker") == "true",
+                DeleteMarkerVersionID: resp.Header.Get("x-amz-version-id"),
+        }
+}
+
+// RemoveObjectError - container of Multi Delete S3 API error
+type RemoveObjectError struct {
+        ObjectName string
+        VersionID  string
+        Err        error
+}
+
+// RemoveObjectResult - container of Multi Delete S3 API result
+type RemoveObjectResult struct {
+        ObjectName      string
+        ObjectVersionID string
+
+        DeleteMarker          bool
+        DeleteMarkerVersionID string
+
+        Err error
+}
+
+// generateRemoveMultiObjects - generate the XML request for remove multi objects request
+func generateRemoveMultiObjectsRequest(objects []ObjectInfo) []byte {
+        delObjects := []deleteObject{}
+        for _, obj := range objects {
+                delObjects = append(delObjects, deleteObject{
+                        Key:       obj.Key,
+                        VersionID: obj.VersionID,
+                })
+        }
+        xmlBytes, _ := xml.Marshal(deleteMultiObjects{Objects: delObjects, Quiet: false})
+        return xmlBytes
+}
+
+// processRemoveMultiObjectsResponse - parse the remove multi objects web service
+// and return the success/failure result status for each object
+func processRemoveMultiObjectsResponse(body io.Reader, resultCh chan<- RemoveObjectResult) {
+        // Parse multi delete XML response
+        rmResult := &deleteMultiObjectsResult{}
+        err := xmlDecoder(body, rmResult)
+        if err != nil {
+                resultCh <- RemoveObjectResult{ObjectName: "", Err: err}
+                return
+        }
+
+        // Fill deletion that returned success
+        for _, obj := range rmResult.DeletedObjects {
+                resultCh <- RemoveObjectResult{
+                        ObjectName: obj.Key,
+                        // Only filled with versioned buckets
+                        ObjectVersionID:       obj.VersionID,
+                        DeleteMarker:          obj.DeleteMarker,
+                        DeleteMarkerVersionID: obj.DeleteMarkerVersionID,
+                }
+        }
+
+        // Fill deletion that returned an error.
+        for _, obj := range rmResult.UnDeletedObjects {
+                // Version does not exist is not an error ignore and continue.
+                switch obj.Code {
+                case "InvalidArgument", "NoSuchVersion":
+                        continue
+                }
+                resultCh <- RemoveObjectResult{
+                        ObjectName:      obj.Key,
+                        ObjectVersionID: obj.VersionID,
+                        Err: ErrorResponse{
+                                Code:    obj.Code,
+                                Message: obj.Message,
+                        },
+                }
+        }
+}
+
+// RemoveObjectsOptions represents options specified by user for RemoveObjects call
+type RemoveObjectsOptions struct {
+        GovernanceBypass bool
+}
+
+// RemoveObjects removes multiple objects from a bucket while
+// it is possible to specify objects versions which are received from
+// objectsCh. Remove failures are sent back via error channel.
+func (c *Client) RemoveObjects(ctx context.Context, bucketName string, objectsCh <-chan ObjectInfo, opts RemoveObjectsOptions) <-chan RemoveObjectError {
+        errorCh := make(chan RemoveObjectError, 1)
+
+        // Validate if bucket name is valid.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                defer close(errorCh)
+                errorCh <- RemoveObjectError{
+                        Err: err,
+                }
+                return errorCh
+        }
+        // Validate objects channel to be properly allocated.
+        if objectsCh == nil {
+                defer close(errorCh)
+                errorCh <- RemoveObjectError{
+                        Err: errInvalidArgument("Objects channel cannot be nil"),
+                }
+                return errorCh
+        }
+
+        resultCh := make(chan RemoveObjectResult, 1)
+        go c.removeObjects(ctx, bucketName, objectsCh, resultCh, opts)
+        go func() {
+                defer close(errorCh)
+                for res := range resultCh {
+                        // Send only errors to the error channel
+                        if res.Err == nil {
+                                continue
+                        }
+                        errorCh <- RemoveObjectError{
+                                ObjectName: res.ObjectName,
+                                VersionID:  res.ObjectVersionID,
+                                Err:        res.Err,
+                        }
+                }
+        }()
+
+        return errorCh
+}
+
+// RemoveObjectsWithResult removes multiple objects from a bucket while
+// it is possible to specify objects versions which are received from
+// objectsCh. Remove results, successes and failures are sent back via
+// RemoveObjectResult channel
+func (c *Client) RemoveObjectsWithResult(ctx context.Context, bucketName string, objectsCh <-chan ObjectInfo, opts RemoveObjectsOptions) <-chan RemoveObjectResult {
+        resultCh := make(chan RemoveObjectResult, 1)
+
+        // Validate if bucket name is valid.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                defer close(resultCh)
+                resultCh <- RemoveObjectResult{
+                        Err: err,
+                }
+                return resultCh
+        }
+        // Validate objects channel to be properly allocated.
+        if objectsCh == nil {
+                defer close(resultCh)
+                resultCh <- RemoveObjectResult{
+                        Err: errInvalidArgument("Objects channel cannot be nil"),
+                }
+                return resultCh
+        }
+
+        go c.removeObjects(ctx, bucketName, objectsCh, resultCh, opts)
+        return resultCh
+}
+
+// Return true if the character is within the allowed characters in an XML 1.0 document
+// The list of allowed characters can be found here: https://www.w3.org/TR/xml/#charsets
+func validXMLChar(r rune) (ok bool) {
+        return r == 0x09 ||
+                r == 0x0A ||
+                r == 0x0D ||
+                r >= 0x20 && r <= 0xD7FF ||
+                r >= 0xE000 && r <= 0xFFFD ||
+                r >= 0x10000 && r <= 0x10FFFF
+}
+
+func hasInvalidXMLChar(str string) bool {
+        for _, s := range str {
+                if !validXMLChar(s) {
+                        return true
+                }
+        }
+        return false
+}
+
+// Generate and call MultiDelete S3 requests based on entries received from objectsCh
+func (c *Client) removeObjects(ctx context.Context, bucketName string, objectsCh <-chan ObjectInfo, resultCh chan<- RemoveObjectResult, opts RemoveObjectsOptions) {
+        maxEntries := 1000
+        finish := false
+        urlValues := make(url.Values)
+        urlValues.Set("delete", "")
+
+        // Close result channel when Multi delete finishes.
+        defer close(resultCh)
+
+        // Loop over entries by 1000 and call MultiDelete requests
+        for {
+                if finish {
+                        break
+                }
+                count := 0
+                var batch []ObjectInfo
+
+                // Try to gather 1000 entries
+                for object := range objectsCh {
+                        if hasInvalidXMLChar(object.Key) {
+                                // Use single DELETE so the object name will be in the request URL instead of the multi-delete XML document.
+                                removeResult := c.removeObject(ctx, bucketName, object.Key, RemoveObjectOptions{
+                                        VersionID:        object.VersionID,
+                                        GovernanceBypass: opts.GovernanceBypass,
+                                })
+                                if err := removeResult.Err; err != nil {
+                                        // Version does not exist is not an error ignore and continue.
+                                        switch ToErrorResponse(err).Code {
+                                        case "InvalidArgument", "NoSuchVersion":
+                                                continue
+                                        }
+                                        resultCh <- removeResult
+                                }
+
+                                resultCh <- removeResult
+                                continue
+                        }
+
+                        batch = append(batch, object)
+                        if count++; count >= maxEntries {
+                                break
+                        }
+                }
+                if count == 0 {
+                        // Multi Objects Delete API doesn't accept empty object list, quit immediately
+                        break
+                }
+                if count < maxEntries {
+                        // We didn't have 1000 entries, so this is the last batch
+                        finish = true
+                }
+
+                // Build headers.
+                headers := make(http.Header)
+                if opts.GovernanceBypass {
+                        // Set the bypass goverenance retention header
+                        headers.Set(amzBypassGovernance, "true")
+                }
+
+                // Generate remove multi objects XML request
+                removeBytes := generateRemoveMultiObjectsRequest(batch)
+                // Execute GET on bucket to list objects.
+                resp, err := c.executeMethod(ctx, http.MethodPost, requestMetadata{
+                        bucketName:       bucketName,
+                        queryValues:      urlValues,
+                        contentBody:      bytes.NewReader(removeBytes),
+                        contentLength:    int64(len(removeBytes)),
+                        contentMD5Base64: sumMD5Base64(removeBytes),
+                        contentSHA256Hex: sum256Hex(removeBytes),
+                        customHeader:     headers,
+                })
+                if resp != nil {
+                        if resp.StatusCode != http.StatusOK {
+                                e := httpRespToErrorResponse(resp, bucketName, "")
+                                resultCh <- RemoveObjectResult{ObjectName: "", Err: e}
+                        }
+                }
+                if err != nil {
+                        for _, b := range batch {
+                                resultCh <- RemoveObjectResult{
+                                        ObjectName:      b.Key,
+                                        ObjectVersionID: b.VersionID,
+                                        Err:             err,
+                                }
+                        }
+                        continue
+                }
+
+                // Process multiobjects remove xml response
+                processRemoveMultiObjectsResponse(resp.Body, resultCh)
+
+                closeResponse(resp)
+        }
+}
+
+// RemoveIncompleteUpload aborts an partially uploaded object.
+func (c *Client) RemoveIncompleteUpload(ctx context.Context, bucketName, objectName string) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return err
+        }
+        // Find multipart upload ids of the object to be aborted.
+        uploadIDs, err := c.findUploadIDs(ctx, bucketName, objectName)
+        if err != nil {
+                return err
+        }
+
+        for _, uploadID := range uploadIDs {
+                // abort incomplete multipart upload, based on the upload id passed.
+                err := c.abortMultipartUpload(ctx, bucketName, objectName, uploadID)
+                if err != nil {
+                        return err
+                }
+        }
+
+        return nil
+}
+
+// abortMultipartUpload aborts a multipart upload for the given
+// uploadID, all previously uploaded parts are deleted.
+func (c *Client) abortMultipartUpload(ctx context.Context, bucketName, objectName, uploadID string) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return err
+        }
+
+        // Initialize url queries.
+        urlValues := make(url.Values)
+        urlValues.Set("uploadId", uploadID)
+
+        // Execute DELETE on multipart upload.
+        resp, err := c.executeMethod(ctx, http.MethodDelete, requestMetadata{
+                bucketName:       bucketName,
+                objectName:       objectName,
+                queryValues:      urlValues,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp != nil {
+                if resp.StatusCode != http.StatusNoContent {
+                        // Abort has no response body, handle it for any errors.
+                        var errorResponse ErrorResponse
+                        switch resp.StatusCode {
+                        case http.StatusNotFound:
+                                // This is needed specifically for abort and it cannot
+                                // be converged into default case.
+                                errorResponse = ErrorResponse{
+                                        Code:       "NoSuchUpload",
+                                        Message:    "The specified multipart upload does not exist.",
+                                        BucketName: bucketName,
+                                        Key:        objectName,
+                                        RequestID:  resp.Header.Get("x-amz-request-id"),
+                                        HostID:     resp.Header.Get("x-amz-id-2"),
+                                        Region:     resp.Header.Get("x-amz-bucket-region"),
+                                }
+                        default:
+                                return httpRespToErrorResponse(resp, bucketName, objectName)
+                        }
+                        return errorResponse
+                }
+        }
+        return nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-restore.go b/vendor/github.com/minio/minio-go/v7/api-restore.go
new file mode 100644
index 0000000..9ec8f4f
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-restore.go
@@ -0,0 +1,182 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * (C) 2018-2021 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/xml"
+        "net/http"
+        "net/url"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+        "github.com/minio/minio-go/v7/pkg/tags"
+)
+
+// RestoreType represents the restore request type
+type RestoreType string
+
+const (
+        // RestoreSelect represents the restore SELECT operation
+        RestoreSelect = RestoreType("SELECT")
+)
+
+// TierType represents a retrieval tier
+type TierType string
+
+const (
+        // TierStandard is the standard retrieval tier
+        TierStandard = TierType("Standard")
+        // TierBulk is the bulk retrieval tier
+        TierBulk = TierType("Bulk")
+        // TierExpedited is the expedited retrieval tier
+        TierExpedited = TierType("Expedited")
+)
+
+// GlacierJobParameters represents the retrieval tier parameter
+type GlacierJobParameters struct {
+        Tier TierType
+}
+
+// Encryption contains the type of server-side encryption used during object retrieval
+type Encryption struct {
+        EncryptionType string
+        KMSContext     string
+        KMSKeyID       string `xml:"KMSKeyId"`
+}
+
+// MetadataEntry represents a metadata information of the restored object.
+type MetadataEntry struct {
+        Name  string
+        Value string
+}
+
+// S3 holds properties of the copy of the archived object
+type S3 struct {
+        AccessControlList *AccessControlList `xml:"AccessControlList,omitempty"`
+        BucketName        string
+        Prefix            string
+        CannedACL         *string        `xml:"CannedACL,omitempty"`
+        Encryption        *Encryption    `xml:"Encryption,omitempty"`
+        StorageClass      *string        `xml:"StorageClass,omitempty"`
+        Tagging           *tags.Tags     `xml:"Tagging,omitempty"`
+        UserMetadata      *MetadataEntry `xml:"UserMetadata,omitempty"`
+}
+
+// SelectParameters holds the select request parameters
+type SelectParameters struct {
+        XMLName             xml.Name `xml:"SelectParameters"`
+        ExpressionType      QueryExpressionType
+        Expression          string
+        InputSerialization  SelectObjectInputSerialization
+        OutputSerialization SelectObjectOutputSerialization
+}
+
+// OutputLocation holds properties of the copy of the archived object
+type OutputLocation struct {
+        XMLName xml.Name `xml:"OutputLocation"`
+        S3      S3       `xml:"S3"`
+}
+
+// RestoreRequest holds properties of the restore object request
+type RestoreRequest struct {
+        XMLName              xml.Name              `xml:"http://s3.amazonaws.com/doc/2006-03-01/ RestoreRequest"`
+        Type                 *RestoreType          `xml:"Type,omitempty"`
+        Tier                 *TierType             `xml:"Tier,omitempty"`
+        Days                 *int                  `xml:"Days,omitempty"`
+        GlacierJobParameters *GlacierJobParameters `xml:"GlacierJobParameters,omitempty"`
+        Description          *string               `xml:"Description,omitempty"`
+        SelectParameters     *SelectParameters     `xml:"SelectParameters,omitempty"`
+        OutputLocation       *OutputLocation       `xml:"OutputLocation,omitempty"`
+}
+
+// SetDays sets the days parameter of the restore request
+func (r *RestoreRequest) SetDays(v int) {
+        r.Days = &v
+}
+
+// SetGlacierJobParameters sets the GlacierJobParameters of the restore request
+func (r *RestoreRequest) SetGlacierJobParameters(v GlacierJobParameters) {
+        r.GlacierJobParameters = &v
+}
+
+// SetType sets the type of the restore request
+func (r *RestoreRequest) SetType(v RestoreType) {
+        r.Type = &v
+}
+
+// SetTier sets the retrieval tier of the restore request
+func (r *RestoreRequest) SetTier(v TierType) {
+        r.Tier = &v
+}
+
+// SetDescription sets the description of the restore request
+func (r *RestoreRequest) SetDescription(v string) {
+        r.Description = &v
+}
+
+// SetSelectParameters sets SelectParameters of the restore select request
+func (r *RestoreRequest) SetSelectParameters(v SelectParameters) {
+        r.SelectParameters = &v
+}
+
+// SetOutputLocation sets the properties of the copy of the archived object
+func (r *RestoreRequest) SetOutputLocation(v OutputLocation) {
+        r.OutputLocation = &v
+}
+
+// RestoreObject is a implementation of https://docs.aws.amazon.com/AmazonS3/latest/API/API_RestoreObject.html AWS S3 API
+func (c *Client) RestoreObject(ctx context.Context, bucketName, objectName, versionID string, req RestoreRequest) error {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return err
+        }
+
+        restoreRequestBytes, err := xml.Marshal(req)
+        if err != nil {
+                return err
+        }
+
+        urlValues := make(url.Values)
+        urlValues.Set("restore", "")
+        if versionID != "" {
+                urlValues.Set("versionId", versionID)
+        }
+
+        // Execute POST on bucket/object.
+        resp, err := c.executeMethod(ctx, http.MethodPost, requestMetadata{
+                bucketName:       bucketName,
+                objectName:       objectName,
+                queryValues:      urlValues,
+                contentMD5Base64: sumMD5Base64(restoreRequestBytes),
+                contentSHA256Hex: sum256Hex(restoreRequestBytes),
+                contentBody:      bytes.NewReader(restoreRequestBytes),
+                contentLength:    int64(len(restoreRequestBytes)),
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return err
+        }
+        if resp.StatusCode != http.StatusAccepted && resp.StatusCode != http.StatusOK {
+                return httpRespToErrorResponse(resp, bucketName, "")
+        }
+        return nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-s3-datatypes.go b/vendor/github.com/minio/minio-go/v7/api-s3-datatypes.go
new file mode 100644
index 0000000..1527b74
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-s3-datatypes.go
@@ -0,0 +1,390 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2020 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 minio
+
+import (
+        "encoding/xml"
+        "errors"
+        "io"
+        "reflect"
+        "time"
+)
+
+// listAllMyBucketsResult container for listBuckets response.
+type listAllMyBucketsResult struct {
+        // Container for one or more buckets.
+        Buckets struct {
+                Bucket []BucketInfo
+        }
+        Owner owner
+}
+
+// owner container for bucket owner information.
+type owner struct {
+        DisplayName string
+        ID          string
+}
+
+// CommonPrefix container for prefix response.
+type CommonPrefix struct {
+        Prefix string
+}
+
+// ListBucketV2Result container for listObjects response version 2.
+type ListBucketV2Result struct {
+        // A response can contain CommonPrefixes only if you have
+        // specified a delimiter.
+        CommonPrefixes []CommonPrefix
+        // Metadata about each object returned.
+        Contents  []ObjectInfo
+        Delimiter string
+
+        // Encoding type used to encode object keys in the response.
+        EncodingType string
+
+        // A flag that indicates whether or not ListObjects returned all of the results
+        // that satisfied the search criteria.
+        IsTruncated bool
+        MaxKeys     int64
+        Name        string
+
+        // Hold the token that will be sent in the next request to fetch the next group of keys
+        NextContinuationToken string
+
+        ContinuationToken string
+        Prefix            string
+
+        // FetchOwner and StartAfter are currently not used
+        FetchOwner string
+        StartAfter string
+}
+
+// Version is an element in the list object versions response
+type Version struct {
+        ETag         string
+        IsLatest     bool
+        Key          string
+        LastModified time.Time
+        Owner        Owner
+        Size         int64
+        StorageClass string
+        VersionID    string `xml:"VersionId"`
+
+        // x-amz-meta-* headers stripped "x-amz-meta-" prefix containing the first value.
+        // Only returned by MinIO servers.
+        UserMetadata StringMap `json:"userMetadata,omitempty"`
+
+        // x-amz-tagging values in their k/v values.
+        // Only returned by MinIO servers.
+        UserTags URLMap `json:"userTags,omitempty" xml:"UserTags"`
+
+        Internal *struct {
+                K int // Data blocks
+                M int // Parity blocks
+        } `xml:"Internal"`
+
+        isDeleteMarker bool
+}
+
+// ListVersionsResult is an element in the list object versions response
+// and has a special Unmarshaler because we need to preserver the order
+// of <Version>  and <DeleteMarker> in ListVersionsResult.Versions slice
+type ListVersionsResult struct {
+        Versions []Version
+
+        CommonPrefixes      []CommonPrefix
+        Name                string
+        Prefix              string
+        Delimiter           string
+        MaxKeys             int64
+        EncodingType        string
+        IsTruncated         bool
+        KeyMarker           string
+        VersionIDMarker     string
+        NextKeyMarker       string
+        NextVersionIDMarker string
+}
+
+// UnmarshalXML is a custom unmarshal code for the response of ListObjectVersions, the custom
+// code will unmarshal <Version> and <DeleteMarker> tags and save them in Versions field to
+// preserve the lexical order of the listing.
+func (l *ListVersionsResult) UnmarshalXML(d *xml.Decoder, _ xml.StartElement) (err error) {
+        for {
+                // Read tokens from the XML document in a stream.
+                t, err := d.Token()
+                if err != nil {
+                        if err == io.EOF {
+                                break
+                        }
+                        return err
+                }
+
+                se, ok := t.(xml.StartElement)
+                if ok {
+                        tagName := se.Name.Local
+                        switch tagName {
+                        case "Name", "Prefix",
+                                "Delimiter", "EncodingType",
+                                "KeyMarker", "NextKeyMarker":
+                                var s string
+                                if err = d.DecodeElement(&s, &se); err != nil {
+                                        return err
+                                }
+                                v := reflect.ValueOf(l).Elem().FieldByName(tagName)
+                                if v.IsValid() {
+                                        v.SetString(s)
+                                }
+                        case "VersionIdMarker":
+                                // VersionIdMarker is a special case because of 'Id' instead of 'ID' in field name
+                                var s string
+                                if err = d.DecodeElement(&s, &se); err != nil {
+                                        return err
+                                }
+                                l.VersionIDMarker = s
+                        case "NextVersionIdMarker":
+                                // NextVersionIdMarker is a special case because of 'Id' instead of 'ID' in field name
+                                var s string
+                                if err = d.DecodeElement(&s, &se); err != nil {
+                                        return err
+                                }
+                                l.NextVersionIDMarker = s
+                        case "IsTruncated": //        bool
+                                var b bool
+                                if err = d.DecodeElement(&b, &se); err != nil {
+                                        return err
+                                }
+                                l.IsTruncated = b
+                        case "MaxKeys": //       int64
+                                var i int64
+                                if err = d.DecodeElement(&i, &se); err != nil {
+                                        return err
+                                }
+                                l.MaxKeys = i
+                        case "CommonPrefixes":
+                                var cp CommonPrefix
+                                if err = d.DecodeElement(&cp, &se); err != nil {
+                                        return err
+                                }
+                                l.CommonPrefixes = append(l.CommonPrefixes, cp)
+                        case "DeleteMarker", "Version":
+                                var v Version
+                                if err = d.DecodeElement(&v, &se); err != nil {
+                                        return err
+                                }
+                                if tagName == "DeleteMarker" {
+                                        v.isDeleteMarker = true
+                                }
+                                l.Versions = append(l.Versions, v)
+                        default:
+                                return errors.New("unrecognized option:" + tagName)
+                        }
+
+                }
+        }
+        return nil
+}
+
+// ListBucketResult container for listObjects response.
+type ListBucketResult struct {
+        // A response can contain CommonPrefixes only if you have
+        // specified a delimiter.
+        CommonPrefixes []CommonPrefix
+        // Metadata about each object returned.
+        Contents  []ObjectInfo
+        Delimiter string
+
+        // Encoding type used to encode object keys in the response.
+        EncodingType string
+
+        // A flag that indicates whether or not ListObjects returned all of the results
+        // that satisfied the search criteria.
+        IsTruncated bool
+        Marker      string
+        MaxKeys     int64
+        Name        string
+
+        // When response is truncated (the IsTruncated element value in
+        // the response is true), you can use the key name in this field
+        // as marker in the subsequent request to get next set of objects.
+        // Object storage lists objects in alphabetical order Note: This
+        // element is returned only if you have delimiter request
+        // parameter specified. If response does not include the NextMaker
+        // and it is truncated, you can use the value of the last Key in
+        // the response as the marker in the subsequent request to get the
+        // next set of object keys.
+        NextMarker string
+        Prefix     string
+}
+
+// ListMultipartUploadsResult container for ListMultipartUploads response
+type ListMultipartUploadsResult struct {
+        Bucket             string
+        KeyMarker          string
+        UploadIDMarker     string `xml:"UploadIdMarker"`
+        NextKeyMarker      string
+        NextUploadIDMarker string `xml:"NextUploadIdMarker"`
+        EncodingType       string
+        MaxUploads         int64
+        IsTruncated        bool
+        Uploads            []ObjectMultipartInfo `xml:"Upload"`
+        Prefix             string
+        Delimiter          string
+        // A response can contain CommonPrefixes only if you specify a delimiter.
+        CommonPrefixes []CommonPrefix
+}
+
+// initiator container for who initiated multipart upload.
+type initiator struct {
+        ID          string
+        DisplayName string
+}
+
+// copyObjectResult container for copy object response.
+type copyObjectResult struct {
+        ETag         string
+        LastModified time.Time // time string format "2006-01-02T15:04:05.000Z"
+}
+
+// ObjectPart container for particular part of an object.
+type ObjectPart struct {
+        // Part number identifies the part.
+        PartNumber int
+
+        // Date and time the part was uploaded.
+        LastModified time.Time
+
+        // Entity tag returned when the part was uploaded, usually md5sum
+        // of the part.
+        ETag string
+
+        // Size of the uploaded part data.
+        Size int64
+
+        // Checksum values of each part.
+        ChecksumCRC32  string
+        ChecksumCRC32C string
+        ChecksumSHA1   string
+        ChecksumSHA256 string
+}
+
+// ListObjectPartsResult container for ListObjectParts response.
+type ListObjectPartsResult struct {
+        Bucket   string
+        Key      string
+        UploadID string `xml:"UploadId"`
+
+        Initiator initiator
+        Owner     owner
+
+        StorageClass         string
+        PartNumberMarker     int
+        NextPartNumberMarker int
+        MaxParts             int
+
+        // Indicates whether the returned list of parts is truncated.
+        IsTruncated bool
+        ObjectParts []ObjectPart `xml:"Part"`
+
+        EncodingType string
+}
+
+// initiateMultipartUploadResult container for InitiateMultiPartUpload
+// response.
+type initiateMultipartUploadResult struct {
+        Bucket   string
+        Key      string
+        UploadID string `xml:"UploadId"`
+}
+
+// completeMultipartUploadResult container for completed multipart
+// upload response.
+type completeMultipartUploadResult struct {
+        Location string
+        Bucket   string
+        Key      string
+        ETag     string
+
+        // Checksum values, hash of hashes of parts.
+        ChecksumCRC32  string
+        ChecksumCRC32C string
+        ChecksumSHA1   string
+        ChecksumSHA256 string
+}
+
+// CompletePart sub container lists individual part numbers and their
+// md5sum, part of completeMultipartUpload.
+type CompletePart struct {
+        // Part number identifies the part.
+        PartNumber int
+        ETag       string
+
+        // Checksum values
+        ChecksumCRC32  string `xml:"ChecksumCRC32,omitempty"`
+        ChecksumCRC32C string `xml:"ChecksumCRC32C,omitempty"`
+        ChecksumSHA1   string `xml:"ChecksumSHA1,omitempty"`
+        ChecksumSHA256 string `xml:"ChecksumSHA256,omitempty"`
+}
+
+// completeMultipartUpload container for completing multipart upload.
+type completeMultipartUpload struct {
+        XMLName xml.Name       `xml:"http://s3.amazonaws.com/doc/2006-03-01/ CompleteMultipartUpload" json:"-"`
+        Parts   []CompletePart `xml:"Part"`
+}
+
+// createBucketConfiguration container for bucket configuration.
+type createBucketConfiguration struct {
+        XMLName  xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ CreateBucketConfiguration" json:"-"`
+        Location string   `xml:"LocationConstraint"`
+}
+
+// deleteObject container for Delete element in MultiObjects Delete XML request
+type deleteObject struct {
+        Key       string
+        VersionID string `xml:"VersionId,omitempty"`
+}
+
+// deletedObject container for Deleted element in MultiObjects Delete XML response
+type deletedObject struct {
+        Key       string
+        VersionID string `xml:"VersionId,omitempty"`
+        // These fields are ignored.
+        DeleteMarker          bool
+        DeleteMarkerVersionID string `xml:"DeleteMarkerVersionId,omitempty"`
+}
+
+// nonDeletedObject container for Error element (failed deletion) in MultiObjects Delete XML response
+type nonDeletedObject struct {
+        Key       string
+        Code      string
+        Message   string
+        VersionID string `xml:"VersionId"`
+}
+
+// deletedMultiObjects container for MultiObjects Delete XML request
+type deleteMultiObjects struct {
+        XMLName xml.Name `xml:"Delete"`
+        Quiet   bool
+        Objects []deleteObject `xml:"Object"`
+}
+
+// deletedMultiObjectsResult container for MultiObjects Delete XML response
+type deleteMultiObjectsResult struct {
+        XMLName          xml.Name           `xml:"DeleteResult"`
+        DeletedObjects   []deletedObject    `xml:"Deleted"`
+        UnDeletedObjects []nonDeletedObject `xml:"Error"`
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-select.go b/vendor/github.com/minio/minio-go/v7/api-select.go
new file mode 100644
index 0000000..628d967
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-select.go
@@ -0,0 +1,757 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * (C) 2018-2020 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/binary"
+        "encoding/xml"
+        "errors"
+        "fmt"
+        "hash"
+        "hash/crc32"
+        "io"
+        "net/http"
+        "net/url"
+        "strings"
+
+        "github.com/minio/minio-go/v7/pkg/encrypt"
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// CSVFileHeaderInfo - is the parameter for whether to utilize headers.
+type CSVFileHeaderInfo string
+
+// Constants for file header info.
+const (
+        CSVFileHeaderInfoNone   CSVFileHeaderInfo = "NONE"
+        CSVFileHeaderInfoIgnore CSVFileHeaderInfo = "IGNORE"
+        CSVFileHeaderInfoUse    CSVFileHeaderInfo = "USE"
+)
+
+// SelectCompressionType - is the parameter for what type of compression is
+// present
+type SelectCompressionType string
+
+// Constants for compression types under select API.
+const (
+        SelectCompressionNONE SelectCompressionType = "NONE"
+        SelectCompressionGZIP SelectCompressionType = "GZIP"
+        SelectCompressionBZIP SelectCompressionType = "BZIP2"
+
+        // Non-standard compression schemes, supported by MinIO hosts:
+
+        SelectCompressionZSTD   SelectCompressionType = "ZSTD"   // Zstandard compression.
+        SelectCompressionLZ4    SelectCompressionType = "LZ4"    // LZ4 Stream
+        SelectCompressionS2     SelectCompressionType = "S2"     // S2 Stream
+        SelectCompressionSNAPPY SelectCompressionType = "SNAPPY" // Snappy stream
+)
+
+// CSVQuoteFields - is the parameter for how CSV fields are quoted.
+type CSVQuoteFields string
+
+// Constants for csv quote styles.
+const (
+        CSVQuoteFieldsAlways   CSVQuoteFields = "Always"
+        CSVQuoteFieldsAsNeeded CSVQuoteFields = "AsNeeded"
+)
+
+// QueryExpressionType - is of what syntax the expression is, this should only
+// be SQL
+type QueryExpressionType string
+
+// Constants for expression type.
+const (
+        QueryExpressionTypeSQL QueryExpressionType = "SQL"
+)
+
+// JSONType determines json input serialization type.
+type JSONType string
+
+// Constants for JSONTypes.
+const (
+        JSONDocumentType JSONType = "DOCUMENT"
+        JSONLinesType    JSONType = "LINES"
+)
+
+// ParquetInputOptions parquet input specific options
+type ParquetInputOptions struct{}
+
+// CSVInputOptions csv input specific options
+type CSVInputOptions struct {
+        FileHeaderInfo    CSVFileHeaderInfo
+        fileHeaderInfoSet bool
+
+        RecordDelimiter    string
+        recordDelimiterSet bool
+
+        FieldDelimiter    string
+        fieldDelimiterSet bool
+
+        QuoteCharacter    string
+        quoteCharacterSet bool
+
+        QuoteEscapeCharacter    string
+        quoteEscapeCharacterSet bool
+
+        Comments    string
+        commentsSet bool
+}
+
+// SetFileHeaderInfo sets the file header info in the CSV input options
+func (c *CSVInputOptions) SetFileHeaderInfo(val CSVFileHeaderInfo) {
+        c.FileHeaderInfo = val
+        c.fileHeaderInfoSet = true
+}
+
+// SetRecordDelimiter sets the record delimiter in the CSV input options
+func (c *CSVInputOptions) SetRecordDelimiter(val string) {
+        c.RecordDelimiter = val
+        c.recordDelimiterSet = true
+}
+
+// SetFieldDelimiter sets the field delimiter in the CSV input options
+func (c *CSVInputOptions) SetFieldDelimiter(val string) {
+        c.FieldDelimiter = val
+        c.fieldDelimiterSet = true
+}
+
+// SetQuoteCharacter sets the quote character in the CSV input options
+func (c *CSVInputOptions) SetQuoteCharacter(val string) {
+        c.QuoteCharacter = val
+        c.quoteCharacterSet = true
+}
+
+// SetQuoteEscapeCharacter sets the quote escape character in the CSV input options
+func (c *CSVInputOptions) SetQuoteEscapeCharacter(val string) {
+        c.QuoteEscapeCharacter = val
+        c.quoteEscapeCharacterSet = true
+}
+
+// SetComments sets the comments character in the CSV input options
+func (c *CSVInputOptions) SetComments(val string) {
+        c.Comments = val
+        c.commentsSet = true
+}
+
+// MarshalXML - produces the xml representation of the CSV input options struct
+func (c CSVInputOptions) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+        if err := e.EncodeToken(start); err != nil {
+                return err
+        }
+        if c.FileHeaderInfo != "" || c.fileHeaderInfoSet {
+                if err := e.EncodeElement(c.FileHeaderInfo, xml.StartElement{Name: xml.Name{Local: "FileHeaderInfo"}}); err != nil {
+                        return err
+                }
+        }
+
+        if c.RecordDelimiter != "" || c.recordDelimiterSet {
+                if err := e.EncodeElement(c.RecordDelimiter, xml.StartElement{Name: xml.Name{Local: "RecordDelimiter"}}); err != nil {
+                        return err
+                }
+        }
+
+        if c.FieldDelimiter != "" || c.fieldDelimiterSet {
+                if err := e.EncodeElement(c.FieldDelimiter, xml.StartElement{Name: xml.Name{Local: "FieldDelimiter"}}); err != nil {
+                        return err
+                }
+        }
+
+        if c.QuoteCharacter != "" || c.quoteCharacterSet {
+                if err := e.EncodeElement(c.QuoteCharacter, xml.StartElement{Name: xml.Name{Local: "QuoteCharacter"}}); err != nil {
+                        return err
+                }
+        }
+
+        if c.QuoteEscapeCharacter != "" || c.quoteEscapeCharacterSet {
+                if err := e.EncodeElement(c.QuoteEscapeCharacter, xml.StartElement{Name: xml.Name{Local: "QuoteEscapeCharacter"}}); err != nil {
+                        return err
+                }
+        }
+
+        if c.Comments != "" || c.commentsSet {
+                if err := e.EncodeElement(c.Comments, xml.StartElement{Name: xml.Name{Local: "Comments"}}); err != nil {
+                        return err
+                }
+        }
+
+        return e.EncodeToken(xml.EndElement{Name: start.Name})
+}
+
+// CSVOutputOptions csv output specific options
+type CSVOutputOptions struct {
+        QuoteFields    CSVQuoteFields
+        quoteFieldsSet bool
+
+        RecordDelimiter    string
+        recordDelimiterSet bool
+
+        FieldDelimiter    string
+        fieldDelimiterSet bool
+
+        QuoteCharacter    string
+        quoteCharacterSet bool
+
+        QuoteEscapeCharacter    string
+        quoteEscapeCharacterSet bool
+}
+
+// SetQuoteFields sets the quote field parameter in the CSV output options
+func (c *CSVOutputOptions) SetQuoteFields(val CSVQuoteFields) {
+        c.QuoteFields = val
+        c.quoteFieldsSet = true
+}
+
+// SetRecordDelimiter sets the record delimiter character in the CSV output options
+func (c *CSVOutputOptions) SetRecordDelimiter(val string) {
+        c.RecordDelimiter = val
+        c.recordDelimiterSet = true
+}
+
+// SetFieldDelimiter sets the field delimiter character in the CSV output options
+func (c *CSVOutputOptions) SetFieldDelimiter(val string) {
+        c.FieldDelimiter = val
+        c.fieldDelimiterSet = true
+}
+
+// SetQuoteCharacter sets the quote character in the CSV output options
+func (c *CSVOutputOptions) SetQuoteCharacter(val string) {
+        c.QuoteCharacter = val
+        c.quoteCharacterSet = true
+}
+
+// SetQuoteEscapeCharacter sets the quote escape character in the CSV output options
+func (c *CSVOutputOptions) SetQuoteEscapeCharacter(val string) {
+        c.QuoteEscapeCharacter = val
+        c.quoteEscapeCharacterSet = true
+}
+
+// MarshalXML - produces the xml representation of the CSVOutputOptions struct
+func (c CSVOutputOptions) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+        if err := e.EncodeToken(start); err != nil {
+                return err
+        }
+
+        if c.QuoteFields != "" || c.quoteFieldsSet {
+                if err := e.EncodeElement(c.QuoteFields, xml.StartElement{Name: xml.Name{Local: "QuoteFields"}}); err != nil {
+                        return err
+                }
+        }
+
+        if c.RecordDelimiter != "" || c.recordDelimiterSet {
+                if err := e.EncodeElement(c.RecordDelimiter, xml.StartElement{Name: xml.Name{Local: "RecordDelimiter"}}); err != nil {
+                        return err
+                }
+        }
+
+        if c.FieldDelimiter != "" || c.fieldDelimiterSet {
+                if err := e.EncodeElement(c.FieldDelimiter, xml.StartElement{Name: xml.Name{Local: "FieldDelimiter"}}); err != nil {
+                        return err
+                }
+        }
+
+        if c.QuoteCharacter != "" || c.quoteCharacterSet {
+                if err := e.EncodeElement(c.QuoteCharacter, xml.StartElement{Name: xml.Name{Local: "QuoteCharacter"}}); err != nil {
+                        return err
+                }
+        }
+
+        if c.QuoteEscapeCharacter != "" || c.quoteEscapeCharacterSet {
+                if err := e.EncodeElement(c.QuoteEscapeCharacter, xml.StartElement{Name: xml.Name{Local: "QuoteEscapeCharacter"}}); err != nil {
+                        return err
+                }
+        }
+
+        return e.EncodeToken(xml.EndElement{Name: start.Name})
+}
+
+// JSONInputOptions json input specific options
+type JSONInputOptions struct {
+        Type    JSONType
+        typeSet bool
+}
+
+// SetType sets the JSON type in the JSON input options
+func (j *JSONInputOptions) SetType(typ JSONType) {
+        j.Type = typ
+        j.typeSet = true
+}
+
+// MarshalXML - produces the xml representation of the JSONInputOptions struct
+func (j JSONInputOptions) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+        if err := e.EncodeToken(start); err != nil {
+                return err
+        }
+
+        if j.Type != "" || j.typeSet {
+                if err := e.EncodeElement(j.Type, xml.StartElement{Name: xml.Name{Local: "Type"}}); err != nil {
+                        return err
+                }
+        }
+
+        return e.EncodeToken(xml.EndElement{Name: start.Name})
+}
+
+// JSONOutputOptions - json output specific options
+type JSONOutputOptions struct {
+        RecordDelimiter    string
+        recordDelimiterSet bool
+}
+
+// SetRecordDelimiter sets the record delimiter in the JSON output options
+func (j *JSONOutputOptions) SetRecordDelimiter(val string) {
+        j.RecordDelimiter = val
+        j.recordDelimiterSet = true
+}
+
+// MarshalXML - produces the xml representation of the JSONOutputOptions struct
+func (j JSONOutputOptions) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+        if err := e.EncodeToken(start); err != nil {
+                return err
+        }
+
+        if j.RecordDelimiter != "" || j.recordDelimiterSet {
+                if err := e.EncodeElement(j.RecordDelimiter, xml.StartElement{Name: xml.Name{Local: "RecordDelimiter"}}); err != nil {
+                        return err
+                }
+        }
+
+        return e.EncodeToken(xml.EndElement{Name: start.Name})
+}
+
+// SelectObjectInputSerialization - input serialization parameters
+type SelectObjectInputSerialization struct {
+        CompressionType SelectCompressionType `xml:"CompressionType,omitempty"`
+        Parquet         *ParquetInputOptions  `xml:"Parquet,omitempty"`
+        CSV             *CSVInputOptions      `xml:"CSV,omitempty"`
+        JSON            *JSONInputOptions     `xml:"JSON,omitempty"`
+}
+
+// SelectObjectOutputSerialization - output serialization parameters.
+type SelectObjectOutputSerialization struct {
+        CSV  *CSVOutputOptions  `xml:"CSV,omitempty"`
+        JSON *JSONOutputOptions `xml:"JSON,omitempty"`
+}
+
+// SelectObjectOptions - represents the input select body
+type SelectObjectOptions struct {
+        XMLName              xml.Name           `xml:"SelectObjectContentRequest" json:"-"`
+        ServerSideEncryption encrypt.ServerSide `xml:"-"`
+        Expression           string
+        ExpressionType       QueryExpressionType
+        InputSerialization   SelectObjectInputSerialization
+        OutputSerialization  SelectObjectOutputSerialization
+        RequestProgress      struct {
+                Enabled bool
+        }
+}
+
+// Header returns the http.Header representation of the SelectObject options.
+func (o SelectObjectOptions) Header() http.Header {
+        headers := make(http.Header)
+        if o.ServerSideEncryption != nil && o.ServerSideEncryption.Type() == encrypt.SSEC {
+                o.ServerSideEncryption.Marshal(headers)
+        }
+        return headers
+}
+
+// SelectObjectType - is the parameter which defines what type of object the
+// operation is being performed on.
+type SelectObjectType string
+
+// Constants for input data types.
+const (
+        SelectObjectTypeCSV     SelectObjectType = "CSV"
+        SelectObjectTypeJSON    SelectObjectType = "JSON"
+        SelectObjectTypeParquet SelectObjectType = "Parquet"
+)
+
+// preludeInfo is used for keeping track of necessary information from the
+// prelude.
+type preludeInfo struct {
+        totalLen  uint32
+        headerLen uint32
+}
+
+// SelectResults is used for the streaming responses from the server.
+type SelectResults struct {
+        pipeReader *io.PipeReader
+        resp       *http.Response
+        stats      *StatsMessage
+        progress   *ProgressMessage
+}
+
+// ProgressMessage is a struct for progress xml message.
+type ProgressMessage struct {
+        XMLName xml.Name `xml:"Progress" json:"-"`
+        StatsMessage
+}
+
+// StatsMessage is a struct for stat xml message.
+type StatsMessage struct {
+        XMLName        xml.Name `xml:"Stats" json:"-"`
+        BytesScanned   int64
+        BytesProcessed int64
+        BytesReturned  int64
+}
+
+// messageType represents the type of message.
+type messageType string
+
+const (
+        errorMsg  messageType = "error"
+        commonMsg messageType = "event"
+)
+
+// eventType represents the type of event.
+type eventType string
+
+// list of event-types returned by Select API.
+const (
+        endEvent      eventType = "End"
+        recordsEvent  eventType = "Records"
+        progressEvent eventType = "Progress"
+        statsEvent    eventType = "Stats"
+)
+
+// contentType represents content type of event.
+type contentType string
+
+const (
+        xmlContent contentType = "text/xml"
+)
+
+// SelectObjectContent is a implementation of http://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectSELECTContent.html AWS S3 API.
+func (c *Client) SelectObjectContent(ctx context.Context, bucketName, objectName string, opts SelectObjectOptions) (*SelectResults, error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return nil, err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return nil, err
+        }
+
+        selectReqBytes, err := xml.Marshal(opts)
+        if err != nil {
+                return nil, err
+        }
+
+        urlValues := make(url.Values)
+        urlValues.Set("select", "")
+        urlValues.Set("select-type", "2")
+
+        // Execute POST on bucket/object.
+        resp, err := c.executeMethod(ctx, http.MethodPost, requestMetadata{
+                bucketName:       bucketName,
+                objectName:       objectName,
+                queryValues:      urlValues,
+                customHeader:     opts.Header(),
+                contentMD5Base64: sumMD5Base64(selectReqBytes),
+                contentSHA256Hex: sum256Hex(selectReqBytes),
+                contentBody:      bytes.NewReader(selectReqBytes),
+                contentLength:    int64(len(selectReqBytes)),
+        })
+        if err != nil {
+                return nil, err
+        }
+
+        return NewSelectResults(resp, bucketName)
+}
+
+// NewSelectResults creates a Select Result parser that parses the response
+// and returns a Reader that will return parsed and assembled select output.
+func NewSelectResults(resp *http.Response, bucketName string) (*SelectResults, error) {
+        if resp.StatusCode != http.StatusOK {
+                return nil, httpRespToErrorResponse(resp, bucketName, "")
+        }
+
+        pipeReader, pipeWriter := io.Pipe()
+        streamer := &SelectResults{
+                resp:       resp,
+                stats:      &StatsMessage{},
+                progress:   &ProgressMessage{},
+                pipeReader: pipeReader,
+        }
+        streamer.start(pipeWriter)
+        return streamer, nil
+}
+
+// Close - closes the underlying response body and the stream reader.
+func (s *SelectResults) Close() error {
+        defer closeResponse(s.resp)
+        return s.pipeReader.Close()
+}
+
+// Read - is a reader compatible implementation for SelectObjectContent records.
+func (s *SelectResults) Read(b []byte) (n int, err error) {
+        return s.pipeReader.Read(b)
+}
+
+// Stats - information about a request's stats when processing is complete.
+func (s *SelectResults) Stats() *StatsMessage {
+        return s.stats
+}
+
+// Progress - information about the progress of a request.
+func (s *SelectResults) Progress() *ProgressMessage {
+        return s.progress
+}
+
+// start is the main function that decodes the large byte array into
+// several events that are sent through the eventstream.
+func (s *SelectResults) start(pipeWriter *io.PipeWriter) {
+        go func() {
+                for {
+                        var prelude preludeInfo
+                        headers := make(http.Header)
+                        var err error
+
+                        // Create CRC code
+                        crc := crc32.New(crc32.IEEETable)
+                        crcReader := io.TeeReader(s.resp.Body, crc)
+
+                        // Extract the prelude(12 bytes) into a struct to extract relevant information.
+                        prelude, err = processPrelude(crcReader, crc)
+                        if err != nil {
+                                pipeWriter.CloseWithError(err)
+                                closeResponse(s.resp)
+                                return
+                        }
+
+                        // Extract the headers(variable bytes) into a struct to extract relevant information
+                        if prelude.headerLen > 0 {
+                                if err = extractHeader(io.LimitReader(crcReader, int64(prelude.headerLen)), headers); err != nil {
+                                        pipeWriter.CloseWithError(err)
+                                        closeResponse(s.resp)
+                                        return
+                                }
+                        }
+
+                        // Get the actual payload length so that the appropriate amount of
+                        // bytes can be read or parsed.
+                        payloadLen := prelude.PayloadLen()
+
+                        m := messageType(headers.Get("message-type"))
+
+                        switch m {
+                        case errorMsg:
+                                pipeWriter.CloseWithError(errors.New(headers.Get("error-code") + ":\"" + headers.Get("error-message") + "\""))
+                                closeResponse(s.resp)
+                                return
+                        case commonMsg:
+                                // Get content-type of the payload.
+                                c := contentType(headers.Get("content-type"))
+
+                                // Get event type of the payload.
+                                e := eventType(headers.Get("event-type"))
+
+                                // Handle all supported events.
+                                switch e {
+                                case endEvent:
+                                        pipeWriter.Close()
+                                        closeResponse(s.resp)
+                                        return
+                                case recordsEvent:
+                                        if _, err = io.Copy(pipeWriter, io.LimitReader(crcReader, payloadLen)); err != nil {
+                                                pipeWriter.CloseWithError(err)
+                                                closeResponse(s.resp)
+                                                return
+                                        }
+                                case progressEvent:
+                                        switch c {
+                                        case xmlContent:
+                                                if err = xmlDecoder(io.LimitReader(crcReader, payloadLen), s.progress); err != nil {
+                                                        pipeWriter.CloseWithError(err)
+                                                        closeResponse(s.resp)
+                                                        return
+                                                }
+                                        default:
+                                                pipeWriter.CloseWithError(fmt.Errorf("Unexpected content-type %s sent for event-type %s", c, progressEvent))
+                                                closeResponse(s.resp)
+                                                return
+                                        }
+                                case statsEvent:
+                                        switch c {
+                                        case xmlContent:
+                                                if err = xmlDecoder(io.LimitReader(crcReader, payloadLen), s.stats); err != nil {
+                                                        pipeWriter.CloseWithError(err)
+                                                        closeResponse(s.resp)
+                                                        return
+                                                }
+                                        default:
+                                                pipeWriter.CloseWithError(fmt.Errorf("Unexpected content-type %s sent for event-type %s", c, statsEvent))
+                                                closeResponse(s.resp)
+                                                return
+                                        }
+                                }
+                        }
+
+                        // Ensures that the full message's CRC is correct and
+                        // that the message is not corrupted
+                        if err := checkCRC(s.resp.Body, crc.Sum32()); err != nil {
+                                pipeWriter.CloseWithError(err)
+                                closeResponse(s.resp)
+                                return
+                        }
+
+                }
+        }()
+}
+
+// PayloadLen is a function that calculates the length of the payload.
+func (p preludeInfo) PayloadLen() int64 {
+        return int64(p.totalLen - p.headerLen - 16)
+}
+
+// processPrelude is the function that reads the 12 bytes of the prelude and
+// ensures the CRC is correct while also extracting relevant information into
+// the struct,
+func processPrelude(prelude io.Reader, crc hash.Hash32) (preludeInfo, error) {
+        var err error
+        pInfo := preludeInfo{}
+
+        // reads total length of the message (first 4 bytes)
+        pInfo.totalLen, err = extractUint32(prelude)
+        if err != nil {
+                return pInfo, err
+        }
+
+        // reads total header length of the message (2nd 4 bytes)
+        pInfo.headerLen, err = extractUint32(prelude)
+        if err != nil {
+                return pInfo, err
+        }
+
+        // checks that the CRC is correct (3rd 4 bytes)
+        preCRC := crc.Sum32()
+        if err := checkCRC(prelude, preCRC); err != nil {
+                return pInfo, err
+        }
+
+        return pInfo, nil
+}
+
+// extracts the relevant information from the Headers.
+func extractHeader(body io.Reader, myHeaders http.Header) error {
+        for {
+                // extracts the first part of the header,
+                headerTypeName, err := extractHeaderType(body)
+                if err != nil {
+                        // Since end of file, we have read all of our headers
+                        if err == io.EOF {
+                                break
+                        }
+                        return err
+                }
+
+                // reads the 7 present in the header and ignores it.
+                extractUint8(body)
+
+                headerValueName, err := extractHeaderValue(body)
+                if err != nil {
+                        return err
+                }
+
+                myHeaders.Set(headerTypeName, headerValueName)
+
+        }
+        return nil
+}
+
+// extractHeaderType extracts the first half of the header message, the header type.
+func extractHeaderType(body io.Reader) (string, error) {
+        // extracts 2 bit integer
+        headerNameLen, err := extractUint8(body)
+        if err != nil {
+                return "", err
+        }
+        // extracts the string with the appropriate number of bytes
+        headerName, err := extractString(body, int(headerNameLen))
+        if err != nil {
+                return "", err
+        }
+        return strings.TrimPrefix(headerName, ":"), nil
+}
+
+// extractsHeaderValue extracts the second half of the header message, the
+// header value
+func extractHeaderValue(body io.Reader) (string, error) {
+        bodyLen, err := extractUint16(body)
+        if err != nil {
+                return "", err
+        }
+        bodyName, err := extractString(body, int(bodyLen))
+        if err != nil {
+                return "", err
+        }
+        return bodyName, nil
+}
+
+// extracts a string from byte array of a particular number of bytes.
+func extractString(source io.Reader, lenBytes int) (string, error) {
+        myVal := make([]byte, lenBytes)
+        _, err := source.Read(myVal)
+        if err != nil {
+                return "", err
+        }
+        return string(myVal), nil
+}
+
+// extractUint32 extracts a 4 byte integer from the byte array.
+func extractUint32(r io.Reader) (uint32, error) {
+        buf := make([]byte, 4)
+        _, err := readFull(r, buf)
+        if err != nil {
+                return 0, err
+        }
+        return binary.BigEndian.Uint32(buf), nil
+}
+
+// extractUint16 extracts a 2 byte integer from the byte array.
+func extractUint16(r io.Reader) (uint16, error) {
+        buf := make([]byte, 2)
+        _, err := readFull(r, buf)
+        if err != nil {
+                return 0, err
+        }
+        return binary.BigEndian.Uint16(buf), nil
+}
+
+// extractUint8 extracts a 1 byte integer from the byte array.
+func extractUint8(r io.Reader) (uint8, error) {
+        buf := make([]byte, 1)
+        _, err := readFull(r, buf)
+        if err != nil {
+                return 0, err
+        }
+        return buf[0], nil
+}
+
+// checkCRC ensures that the CRC matches with the one from the reader.
+func checkCRC(r io.Reader, expect uint32) error {
+        msgCRC, err := extractUint32(r)
+        if err != nil {
+                return err
+        }
+
+        if msgCRC != expect {
+                return fmt.Errorf("Checksum Mismatch, MessageCRC of 0x%X does not equal expected CRC of 0x%X", msgCRC, expect)
+        }
+        return nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api-stat.go b/vendor/github.com/minio/minio-go/v7/api-stat.go
new file mode 100644
index 0000000..b043dc4
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api-stat.go
@@ -0,0 +1,116 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2020 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 minio
+
+import (
+        "context"
+        "net/http"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// BucketExists verifies if bucket exists and you have permission to access it. Allows for a Context to
+// control cancellations and timeouts.
+func (c *Client) BucketExists(ctx context.Context, bucketName string) (bool, error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return false, err
+        }
+
+        // Execute HEAD on bucketName.
+        resp, err := c.executeMethod(ctx, http.MethodHead, requestMetadata{
+                bucketName:       bucketName,
+                contentSHA256Hex: emptySHA256Hex,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                if ToErrorResponse(err).Code == "NoSuchBucket" {
+                        return false, nil
+                }
+                return false, err
+        }
+        if resp != nil {
+                resperr := httpRespToErrorResponse(resp, bucketName, "")
+                if ToErrorResponse(resperr).Code == "NoSuchBucket" {
+                        return false, nil
+                }
+                if resp.StatusCode != http.StatusOK {
+                        return false, httpRespToErrorResponse(resp, bucketName, "")
+                }
+        }
+        return true, nil
+}
+
+// StatObject verifies if object exists, you have permission to access it
+// and returns information about the object.
+func (c *Client) StatObject(ctx context.Context, bucketName, objectName string, opts StatObjectOptions) (ObjectInfo, error) {
+        // Input validation.
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return ObjectInfo{}, err
+        }
+        if err := s3utils.CheckValidObjectName(objectName); err != nil {
+                return ObjectInfo{}, err
+        }
+        headers := opts.Header()
+        if opts.Internal.ReplicationDeleteMarker {
+                headers.Set(minIOBucketReplicationDeleteMarker, "true")
+        }
+        if opts.Internal.IsReplicationReadyForDeleteMarker {
+                headers.Set(isMinioTgtReplicationReady, "true")
+        }
+
+        // Execute HEAD on objectName.
+        resp, err := c.executeMethod(ctx, http.MethodHead, requestMetadata{
+                bucketName:       bucketName,
+                objectName:       objectName,
+                queryValues:      opts.toQueryValues(),
+                contentSHA256Hex: emptySHA256Hex,
+                customHeader:     headers,
+        })
+        defer closeResponse(resp)
+        if err != nil {
+                return ObjectInfo{}, err
+        }
+
+        if resp != nil {
+                deleteMarker := resp.Header.Get(amzDeleteMarker) == "true"
+                replicationReady := resp.Header.Get(minioTgtReplicationReady) == "true"
+                if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusPartialContent {
+                        if resp.StatusCode == http.StatusMethodNotAllowed && opts.VersionID != "" && deleteMarker {
+                                errResp := ErrorResponse{
+                                        StatusCode: resp.StatusCode,
+                                        Code:       "MethodNotAllowed",
+                                        Message:    "The specified method is not allowed against this resource.",
+                                        BucketName: bucketName,
+                                        Key:        objectName,
+                                }
+                                return ObjectInfo{
+                                        VersionID:      resp.Header.Get(amzVersionID),
+                                        IsDeleteMarker: deleteMarker,
+                                }, errResp
+                        }
+                        return ObjectInfo{
+                                VersionID:        resp.Header.Get(amzVersionID),
+                                IsDeleteMarker:   deleteMarker,
+                                ReplicationReady: replicationReady, // whether delete marker can be replicated
+                        }, httpRespToErrorResponse(resp, bucketName, objectName)
+                }
+        }
+
+        return ToObjectInfo(bucketName, objectName, resp.Header)
+}
diff --git a/vendor/github.com/minio/minio-go/v7/api.go b/vendor/github.com/minio/minio-go/v7/api.go
new file mode 100644
index 0000000..f8a9b34
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/api.go
@@ -0,0 +1,995 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2023 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 minio
+
+import (
+        "bytes"
+        "context"
+        "encoding/base64"
+        "errors"
+        "fmt"
+        "hash/crc32"
+        "io"
+        "math/rand"
+        "net"
+        "net/http"
+        "net/http/cookiejar"
+        "net/http/httptrace"
+        "net/http/httputil"
+        "net/url"
+        "os"
+        "runtime"
+        "strings"
+        "sync"
+        "sync/atomic"
+        "time"
+
+        md5simd "github.com/minio/md5-simd"
+        "github.com/minio/minio-go/v7/pkg/credentials"
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+        "github.com/minio/minio-go/v7/pkg/signer"
+        "golang.org/x/net/publicsuffix"
+)
+
+// Client implements Amazon S3 compatible methods.
+type Client struct {
+        //  Standard options.
+
+        // Parsed endpoint url provided by the user.
+        endpointURL *url.URL
+
+        // Holds various credential providers.
+        credsProvider *credentials.Credentials
+
+        // Custom signerType value overrides all credentials.
+        overrideSignerType credentials.SignatureType
+
+        // User supplied.
+        appInfo struct {
+                appName    string
+                appVersion string
+        }
+
+        // Indicate whether we are using https or not
+        secure bool
+
+        // Needs allocation.
+        httpClient     *http.Client
+        httpTrace      *httptrace.ClientTrace
+        bucketLocCache *bucketLocationCache
+
+        // Advanced functionality.
+        isTraceEnabled  bool
+        traceErrorsOnly bool
+        traceOutput     io.Writer
+
+        // S3 specific accelerated endpoint.
+        s3AccelerateEndpoint string
+
+        // Region endpoint
+        region string
+
+        // Random seed.
+        random *rand.Rand
+
+        // lookup indicates type of url lookup supported by server. If not specified,
+        // default to Auto.
+        lookup BucketLookupType
+
+        // Factory for MD5 hash functions.
+        md5Hasher    func() md5simd.Hasher
+        sha256Hasher func() md5simd.Hasher
+
+        healthStatus int32
+
+        trailingHeaderSupport bool
+}
+
+// Options for New method
+type Options struct {
+        Creds        *credentials.Credentials
+        Secure       bool
+        Transport    http.RoundTripper
+        Trace        *httptrace.ClientTrace
+        Region       string
+        BucketLookup BucketLookupType
+
+        // Allows setting a custom region lookup based on URL pattern
+        // not all URL patterns are covered by this library so if you
+        // have a custom endpoints with many regions you can use this
+        // function to perform region lookups appropriately.
+        CustomRegionViaURL func(u url.URL) string
+
+        // TrailingHeaders indicates server support of trailing headers.
+        // Only supported for v4 signatures.
+        TrailingHeaders bool
+
+        // Custom hash routines. Leave nil to use standard.
+        CustomMD5    func() md5simd.Hasher
+        CustomSHA256 func() md5simd.Hasher
+}
+
+// Global constants.
+const (
+        libraryName    = "minio-go"
+        libraryVersion = "v7.0.66"
+)
+
+// User Agent should always following the below style.
+// Please open an issue to discuss any new changes here.
+//
+//      MinIO (OS; ARCH) LIB/VER APP/VER
+const (
+        libraryUserAgentPrefix = "MinIO (" + runtime.GOOS + "; " + runtime.GOARCH + ") "
+        libraryUserAgent       = libraryUserAgentPrefix + libraryName + "/" + libraryVersion
+)
+
+// BucketLookupType is type of url lookup supported by server.
+type BucketLookupType int
+
+// Different types of url lookup supported by the server.Initialized to BucketLookupAuto
+const (
+        BucketLookupAuto BucketLookupType = iota
+        BucketLookupDNS
+        BucketLookupPath
+)
+
+// New - instantiate minio client with options
+func New(endpoint string, opts *Options) (*Client, error) {
+        if opts == nil {
+                return nil, errors.New("no options provided")
+        }
+        clnt, err := privateNew(endpoint, opts)
+        if err != nil {
+                return nil, err
+        }
+        // If Amazon S3 set to signature v4.
+        if s3utils.IsAmazonEndpoint(*clnt.endpointURL) {
+                clnt.overrideSignerType = credentials.SignatureV4
+        }
+
+        return clnt, nil
+}
+
+// EndpointURL returns the URL of the S3 endpoint.
+func (c *Client) EndpointURL() *url.URL {
+        endpoint := *c.endpointURL // copy to prevent callers from modifying internal state
+        return &endpoint
+}
+
+// lockedRandSource provides protected rand source, implements rand.Source interface.
+type lockedRandSource struct {
+        lk  sync.Mutex
+        src rand.Source
+}
+
+// Int63 returns a non-negative pseudo-random 63-bit integer as an int64.
+func (r *lockedRandSource) Int63() (n int64) {
+        r.lk.Lock()
+        n = r.src.Int63()
+        r.lk.Unlock()
+        return
+}
+
+// Seed uses the provided seed value to initialize the generator to a
+// deterministic state.
+func (r *lockedRandSource) Seed(seed int64) {
+        r.lk.Lock()
+        r.src.Seed(seed)
+        r.lk.Unlock()
+}
+
+func privateNew(endpoint string, opts *Options) (*Client, error) {
+        // construct endpoint.
+        endpointURL, err := getEndpointURL(endpoint, opts.Secure)
+        if err != nil {
+                return nil, err
+        }
+
+        // Initialize cookies to preserve server sent cookies if any and replay
+        // them upon each request.
+        jar, err := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
+        if err != nil {
+                return nil, err
+        }
+
+        // instantiate new Client.
+        clnt := new(Client)
+
+        // Save the credentials.
+        clnt.credsProvider = opts.Creds
+
+        // Remember whether we are using https or not
+        clnt.secure = opts.Secure
+
+        // Save endpoint URL, user agent for future uses.
+        clnt.endpointURL = endpointURL
+
+        transport := opts.Transport
+        if transport == nil {
+                transport, err = DefaultTransport(opts.Secure)
+                if err != nil {
+                        return nil, err
+                }
+        }
+
+        clnt.httpTrace = opts.Trace
+
+        // Instantiate http client and bucket location cache.
+        clnt.httpClient = &http.Client{
+                Jar:       jar,
+                Transport: transport,
+                CheckRedirect: func(req *http.Request, via []*http.Request) error {
+                        return http.ErrUseLastResponse
+                },
+        }
+
+        // Sets custom region, if region is empty bucket location cache is used automatically.
+        if opts.Region == "" {
+                if opts.CustomRegionViaURL != nil {
+                        opts.Region = opts.CustomRegionViaURL(*clnt.endpointURL)
+                } else {
+                        opts.Region = s3utils.GetRegionFromURL(*clnt.endpointURL)
+                }
+        }
+        clnt.region = opts.Region
+
+        // Instantiate bucket location cache.
+        clnt.bucketLocCache = newBucketLocationCache()
+
+        // Introduce a new locked random seed.
+        clnt.random = rand.New(&lockedRandSource{src: rand.NewSource(time.Now().UTC().UnixNano())})
+
+        // Add default md5 hasher.
+        clnt.md5Hasher = opts.CustomMD5
+        clnt.sha256Hasher = opts.CustomSHA256
+        if clnt.md5Hasher == nil {
+                clnt.md5Hasher = newMd5Hasher
+        }
+        if clnt.sha256Hasher == nil {
+                clnt.sha256Hasher = newSHA256Hasher
+        }
+
+        clnt.trailingHeaderSupport = opts.TrailingHeaders && clnt.overrideSignerType.IsV4()
+
+        // Sets bucket lookup style, whether server accepts DNS or Path lookup. Default is Auto - determined
+        // by the SDK. When Auto is specified, DNS lookup is used for Amazon/Google cloud endpoints and Path for all other endpoints.
+        clnt.lookup = opts.BucketLookup
+
+        // healthcheck is not initialized
+        clnt.healthStatus = unknown
+
+        // Return.
+        return clnt, nil
+}
+
+// SetAppInfo - add application details to user agent.
+func (c *Client) SetAppInfo(appName, appVersion string) {
+        // if app name and version not set, we do not set a new user agent.
+        if appName != "" && appVersion != "" {
+                c.appInfo.appName = appName
+                c.appInfo.appVersion = appVersion
+        }
+}
+
+// TraceOn - enable HTTP tracing.
+func (c *Client) TraceOn(outputStream io.Writer) {
+        // if outputStream is nil then default to os.Stdout.
+        if outputStream == nil {
+                outputStream = os.Stdout
+        }
+        // Sets a new output stream.
+        c.traceOutput = outputStream
+
+        // Enable tracing.
+        c.isTraceEnabled = true
+}
+
+// TraceErrorsOnlyOn - same as TraceOn, but only errors will be traced.
+func (c *Client) TraceErrorsOnlyOn(outputStream io.Writer) {
+        c.TraceOn(outputStream)
+        c.traceErrorsOnly = true
+}
+
+// TraceErrorsOnlyOff - Turns off the errors only tracing and everything will be traced after this call.
+// If all tracing needs to be turned off, call TraceOff().
+func (c *Client) TraceErrorsOnlyOff() {
+        c.traceErrorsOnly = false
+}
+
+// TraceOff - disable HTTP tracing.
+func (c *Client) TraceOff() {
+        // Disable tracing.
+        c.isTraceEnabled = false
+        c.traceErrorsOnly = false
+}
+
+// SetS3TransferAccelerate - turns s3 accelerated endpoint on or off for all your
+// requests. This feature is only specific to S3 for all other endpoints this
+// function does nothing. To read further details on s3 transfer acceleration
+// please vist -
+// http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html
+func (c *Client) SetS3TransferAccelerate(accelerateEndpoint string) {
+        if s3utils.IsAmazonEndpoint(*c.endpointURL) {
+                c.s3AccelerateEndpoint = accelerateEndpoint
+        }
+}
+
+// Hash materials provides relevant initialized hash algo writers
+// based on the expected signature type.
+//
+//   - For signature v4 request if the connection is insecure compute only sha256.
+//   - For signature v4 request if the connection is secure compute only md5.
+//   - For anonymous request compute md5.
+func (c *Client) hashMaterials(isMd5Requested, isSha256Requested bool) (hashAlgos map[string]md5simd.Hasher, hashSums map[string][]byte) {
+        hashSums = make(map[string][]byte)
+        hashAlgos = make(map[string]md5simd.Hasher)
+        if c.overrideSignerType.IsV4() {
+                if c.secure {
+                        hashAlgos["md5"] = c.md5Hasher()
+                } else {
+                        if isSha256Requested {
+                                hashAlgos["sha256"] = c.sha256Hasher()
+                        }
+                }
+        } else {
+                if c.overrideSignerType.IsAnonymous() {
+                        hashAlgos["md5"] = c.md5Hasher()
+                }
+        }
+        if isMd5Requested {
+                hashAlgos["md5"] = c.md5Hasher()
+        }
+        return hashAlgos, hashSums
+}
+
+const (
+        unknown = -1
+        offline = 0
+        online  = 1
+)
+
+// IsOnline returns true if healthcheck enabled and client is online.
+// If HealthCheck function has not been called this will always return true.
+func (c *Client) IsOnline() bool {
+        return !c.IsOffline()
+}
+
+// sets online healthStatus to offline
+func (c *Client) markOffline() {
+        atomic.CompareAndSwapInt32(&c.healthStatus, online, offline)
+}
+
+// IsOffline returns true if healthcheck enabled and client is offline
+// If HealthCheck function has not been called this will always return false.
+func (c *Client) IsOffline() bool {
+        return atomic.LoadInt32(&c.healthStatus) == offline
+}
+
+// HealthCheck starts a healthcheck to see if endpoint is up.
+// Returns a context cancellation function, to stop the health check,
+// and an error if health check is already started.
+func (c *Client) HealthCheck(hcDuration time.Duration) (context.CancelFunc, error) {
+        if atomic.LoadInt32(&c.healthStatus) != unknown {
+                return nil, fmt.Errorf("health check is running")
+        }
+        if hcDuration < 1*time.Second {
+                return nil, fmt.Errorf("health check duration should be at least 1 second")
+        }
+        probeBucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "probe-health-")
+        ctx, cancelFn := context.WithCancel(context.Background())
+        atomic.StoreInt32(&c.healthStatus, offline)
+        {
+                // Change to online, if we can connect.
+                gctx, gcancel := context.WithTimeout(ctx, 3*time.Second)
+                _, err := c.getBucketLocation(gctx, probeBucketName)
+                gcancel()
+                if !IsNetworkOrHostDown(err, false) {
+                        switch ToErrorResponse(err).Code {
+                        case "NoSuchBucket", "AccessDenied", "":
+                                atomic.CompareAndSwapInt32(&c.healthStatus, offline, online)
+                        }
+                }
+        }
+
+        go func(duration time.Duration) {
+                timer := time.NewTimer(duration)
+                defer timer.Stop()
+                for {
+                        select {
+                        case <-ctx.Done():
+                                atomic.StoreInt32(&c.healthStatus, unknown)
+                                return
+                        case <-timer.C:
+                                // Do health check the first time and ONLY if the connection is marked offline
+                                if c.IsOffline() {
+                                        gctx, gcancel := context.WithTimeout(context.Background(), 3*time.Second)
+                                        _, err := c.getBucketLocation(gctx, probeBucketName)
+                                        gcancel()
+                                        if !IsNetworkOrHostDown(err, false) {
+                                                switch ToErrorResponse(err).Code {
+                                                case "NoSuchBucket", "AccessDenied", "":
+                                                        atomic.CompareAndSwapInt32(&c.healthStatus, offline, online)
+                                                }
+                                        }
+                                }
+
+                                timer.Reset(duration)
+                        }
+                }
+        }(hcDuration)
+        return cancelFn, nil
+}
+
+// requestMetadata - is container for all the values to make a request.
+type requestMetadata struct {
+        // If set newRequest presigns the URL.
+        presignURL bool
+
+        // User supplied.
+        bucketName         string
+        objectName         string
+        queryValues        url.Values
+        customHeader       http.Header
+        extraPresignHeader http.Header
+        expires            int64
+
+        // Generated by our internal code.
+        bucketLocation   string
+        contentBody      io.Reader
+        contentLength    int64
+        contentMD5Base64 string // carries base64 encoded md5sum
+        contentSHA256Hex string // carries hex encoded sha256sum
+        streamSha256     bool
+        addCrc           bool
+        trailer          http.Header // (http.Request).Trailer. Requires v4 signature.
+}
+
+// dumpHTTP - dump HTTP request and response.
+func (c *Client) dumpHTTP(req *http.Request, resp *http.Response) error {
+        // Starts http dump.
+        _, err := fmt.Fprintln(c.traceOutput, "---------START-HTTP---------")
+        if err != nil {
+                return err
+        }
+
+        // Filter out Signature field from Authorization header.
+        origAuth := req.Header.Get("Authorization")
+        if origAuth != "" {
+                req.Header.Set("Authorization", redactSignature(origAuth))
+        }
+
+        // Only display request header.
+        reqTrace, err := httputil.DumpRequestOut(req, false)
+        if err != nil {
+                return err
+        }
+
+        // Write request to trace output.
+        _, err = fmt.Fprint(c.traceOutput, string(reqTrace))
+        if err != nil {
+                return err
+        }
+
+        // Only display response header.
+        var respTrace []byte
+
+        // For errors we make sure to dump response body as well.
+        if resp.StatusCode != http.StatusOK &&
+                resp.StatusCode != http.StatusPartialContent &&
+                resp.StatusCode != http.StatusNoContent {
+                respTrace, err = httputil.DumpResponse(resp, true)
+                if err != nil {
+                        return err
+                }
+        } else {
+                respTrace, err = httputil.DumpResponse(resp, false)
+                if err != nil {
+                        return err
+                }
+        }
+
+        // Write response to trace output.
+        _, err = fmt.Fprint(c.traceOutput, strings.TrimSuffix(string(respTrace), "\r\n"))
+        if err != nil {
+                return err
+        }
+
+        // Ends the http dump.
+        _, err = fmt.Fprintln(c.traceOutput, "---------END-HTTP---------")
+        if err != nil {
+                return err
+        }
+
+        // Returns success.
+        return nil
+}
+
+// do - execute http request.
+func (c *Client) do(req *http.Request) (resp *http.Response, err error) {
+        defer func() {
+                if IsNetworkOrHostDown(err, false) {
+                        c.markOffline()
+                }
+        }()
+
+        resp, err = c.httpClient.Do(req)
+        if err != nil {
+                // Handle this specifically for now until future Golang versions fix this issue properly.
+                if urlErr, ok := err.(*url.Error); ok {
+                        if strings.Contains(urlErr.Err.Error(), "EOF") {
+                                return nil, &url.Error{
+                                        Op:  urlErr.Op,
+                                        URL: urlErr.URL,
+                                        Err: errors.New("Connection closed by foreign host " + urlErr.URL + ". Retry again."),
+                                }
+                        }
+                }
+                return nil, err
+        }
+
+        // Response cannot be non-nil, report error if thats the case.
+        if resp == nil {
+                msg := "Response is empty. " + reportIssue
+                return nil, errInvalidArgument(msg)
+        }
+
+        // If trace is enabled, dump http request and response,
+        // except when the traceErrorsOnly enabled and the response's status code is ok
+        if c.isTraceEnabled && !(c.traceErrorsOnly && resp.StatusCode == http.StatusOK) {
+                err = c.dumpHTTP(req, resp)
+                if err != nil {
+                        return nil, err
+                }
+        }
+
+        return resp, nil
+}
+
+// List of success status.
+var successStatus = []int{
+        http.StatusOK,
+        http.StatusNoContent,
+        http.StatusPartialContent,
+}
+
+// executeMethod - instantiates a given method, and retries the
+// request upon any error up to maxRetries attempts in a binomially
+// delayed manner using a standard back off algorithm.
+func (c *Client) executeMethod(ctx context.Context, method string, metadata requestMetadata) (res *http.Response, err error) {
+        if c.IsOffline() {
+                return nil, errors.New(c.endpointURL.String() + " is offline.")
+        }
+
+        var retryable bool       // Indicates if request can be retried.
+        var bodySeeker io.Seeker // Extracted seeker from io.Reader.
+        reqRetry := MaxRetry     // Indicates how many times we can retry the request
+
+        if metadata.contentBody != nil {
+                // Check if body is seekable then it is retryable.
+                bodySeeker, retryable = metadata.contentBody.(io.Seeker)
+                switch bodySeeker {
+                case os.Stdin, os.Stdout, os.Stderr:
+                        retryable = false
+                }
+                // Retry only when reader is seekable
+                if !retryable {
+                        reqRetry = 1
+                }
+
+                // Figure out if the body can be closed - if yes
+                // we will definitely close it upon the function
+                // return.
+                bodyCloser, ok := metadata.contentBody.(io.Closer)
+                if ok {
+                        defer bodyCloser.Close()
+                }
+        }
+
+        // Create cancel context to control 'newRetryTimer' go routine.
+        retryCtx, cancel := context.WithCancel(ctx)
+
+        // Indicate to our routine to exit cleanly upon return.
+        defer cancel()
+
+        for range c.newRetryTimer(retryCtx, reqRetry, DefaultRetryUnit, DefaultRetryCap, MaxJitter) {
+                // Retry executes the following function body if request has an
+                // error until maxRetries have been exhausted, retry attempts are
+                // performed after waiting for a given period of time in a
+                // binomial fashion.
+                if retryable {
+                        // Seek back to beginning for each attempt.
+                        if _, err = bodySeeker.Seek(0, 0); err != nil {
+                                // If seek failed, no need to retry.
+                                return nil, err
+                        }
+                }
+
+                if metadata.addCrc {
+                        if metadata.trailer == nil {
+                                metadata.trailer = make(http.Header, 1)
+                        }
+                        crc := crc32.New(crc32.MakeTable(crc32.Castagnoli))
+                        metadata.contentBody = newHashReaderWrapper(metadata.contentBody, crc, func(hash []byte) {
+                                // Update trailer when done.
+                                metadata.trailer.Set("x-amz-checksum-crc32c", base64.StdEncoding.EncodeToString(hash))
+                        })
+                        metadata.trailer.Set("x-amz-checksum-crc32c", base64.StdEncoding.EncodeToString(crc.Sum(nil)))
+                }
+                // Instantiate a new request.
+                var req *http.Request
+                req, err = c.newRequest(ctx, method, metadata)
+                if err != nil {
+                        errResponse := ToErrorResponse(err)
+                        if isS3CodeRetryable(errResponse.Code) {
+                                continue // Retry.
+                        }
+
+                        return nil, err
+                }
+
+                // Initiate the request.
+                res, err = c.do(req)
+                if err != nil {
+                        if isRequestErrorRetryable(err) {
+                                // Retry the request
+                                continue
+                        }
+                        return nil, err
+                }
+
+                // For any known successful http status, return quickly.
+                for _, httpStatus := range successStatus {
+                        if httpStatus == res.StatusCode {
+                                return res, nil
+                        }
+                }
+
+                // Read the body to be saved later.
+                errBodyBytes, err := io.ReadAll(res.Body)
+                // res.Body should be closed
+                closeResponse(res)
+                if err != nil {
+                        return nil, err
+                }
+
+                // Save the body.
+                errBodySeeker := bytes.NewReader(errBodyBytes)
+                res.Body = io.NopCloser(errBodySeeker)
+
+                // For errors verify if its retryable otherwise fail quickly.
+                errResponse := ToErrorResponse(httpRespToErrorResponse(res, metadata.bucketName, metadata.objectName))
+
+                // Save the body back again.
+                errBodySeeker.Seek(0, 0) // Seek back to starting point.
+                res.Body = io.NopCloser(errBodySeeker)
+
+                // Bucket region if set in error response and the error
+                // code dictates invalid region, we can retry the request
+                // with the new region.
+                //
+                // Additionally, we should only retry if bucketLocation and custom
+                // region is empty.
+                if c.region == "" {
+                        switch errResponse.Code {
+                        case "AuthorizationHeaderMalformed":
+                                fallthrough
+                        case "InvalidRegion":
+                                fallthrough
+                        case "AccessDenied":
+                                if errResponse.Region == "" {
+                                        // Region is empty we simply return the error.
+                                        return res, err
+                                }
+                                // Region is not empty figure out a way to
+                                // handle this appropriately.
+                                if metadata.bucketName != "" {
+                                        // Gather Cached location only if bucketName is present.
+                                        if location, cachedOk := c.bucketLocCache.Get(metadata.bucketName); cachedOk && location != errResponse.Region {
+                                                c.bucketLocCache.Set(metadata.bucketName, errResponse.Region)
+                                                continue // Retry.
+                                        }
+                                } else {
+                                        // This is for ListBuckets() fallback.
+                                        if errResponse.Region != metadata.bucketLocation {
+                                                // Retry if the error response has a different region
+                                                // than the request we just made.
+                                                metadata.bucketLocation = errResponse.Region
+                                                continue // Retry
+                                        }
+                                }
+                        }
+                }
+
+                // Verify if error response code is retryable.
+                if isS3CodeRetryable(errResponse.Code) {
+                        continue // Retry.
+                }
+
+                // Verify if http status code is retryable.
+                if isHTTPStatusRetryable(res.StatusCode) {
+                        continue // Retry.
+                }
+
+                // For all other cases break out of the retry loop.
+                break
+        }
+
+        // Return an error when retry is canceled or deadlined
+        if e := retryCtx.Err(); e != nil {
+                return nil, e
+        }
+
+        return res, err
+}
+
+// newRequest - instantiate a new HTTP request for a given method.
+func (c *Client) newRequest(ctx context.Context, method string, metadata requestMetadata) (req *http.Request, err error) {
+        // If no method is supplied default to 'POST'.
+        if method == "" {
+                method = http.MethodPost
+        }
+
+        location := metadata.bucketLocation
+        if location == "" {
+                if metadata.bucketName != "" {
+                        // Gather location only if bucketName is present.
+                        location, err = c.getBucketLocation(ctx, metadata.bucketName)
+                        if err != nil {
+                                return nil, err
+                        }
+                }
+                if location == "" {
+                        location = getDefaultLocation(*c.endpointURL, c.region)
+                }
+        }
+
+        // Look if target url supports virtual host.
+        // We explicitly disallow MakeBucket calls to not use virtual DNS style,
+        // since the resolution may fail.
+        isMakeBucket := (metadata.objectName == "" && method == http.MethodPut && len(metadata.queryValues) == 0)
+        isVirtualHost := c.isVirtualHostStyleRequest(*c.endpointURL, metadata.bucketName) && !isMakeBucket
+
+        // Construct a new target URL.
+        targetURL, err := c.makeTargetURL(metadata.bucketName, metadata.objectName, location,
+                isVirtualHost, metadata.queryValues)
+        if err != nil {
+                return nil, err
+        }
+
+        if c.httpTrace != nil {
+                ctx = httptrace.WithClientTrace(ctx, c.httpTrace)
+        }
+
+        // Initialize a new HTTP request for the method.
+        req, err = http.NewRequestWithContext(ctx, method, targetURL.String(), nil)
+        if err != nil {
+                return nil, err
+        }
+
+        // Get credentials from the configured credentials provider.
+        value, err := c.credsProvider.Get()
+        if err != nil {
+                return nil, err
+        }
+
+        var (
+                signerType      = value.SignerType
+                accessKeyID     = value.AccessKeyID
+                secretAccessKey = value.SecretAccessKey
+                sessionToken    = value.SessionToken
+        )
+
+        // Custom signer set then override the behavior.
+        if c.overrideSignerType != credentials.SignatureDefault {
+                signerType = c.overrideSignerType
+        }
+
+        // If signerType returned by credentials helper is anonymous,
+        // then do not sign regardless of signerType override.
+        if value.SignerType == credentials.SignatureAnonymous {
+                signerType = credentials.SignatureAnonymous
+        }
+
+        // Generate presign url if needed, return right here.
+        if metadata.expires != 0 && metadata.presignURL {
+                if signerType.IsAnonymous() {
+                        return nil, errInvalidArgument("Presigned URLs cannot be generated with anonymous credentials.")
+                }
+                if metadata.extraPresignHeader != nil {
+                        if signerType.IsV2() {
+                                return nil, errInvalidArgument("Extra signed headers for Presign with Signature V2 is not supported.")
+                        }
+                        for k, v := range metadata.extraPresignHeader {
+                                req.Header.Set(k, v[0])
+                        }
+                }
+                if signerType.IsV2() {
+                        // Presign URL with signature v2.
+                        req = signer.PreSignV2(*req, accessKeyID, secretAccessKey, metadata.expires, isVirtualHost)
+                } else if signerType.IsV4() {
+                        // Presign URL with signature v4.
+                        req = signer.PreSignV4(*req, accessKeyID, secretAccessKey, sessionToken, location, metadata.expires)
+                }
+                return req, nil
+        }
+
+        // Set 'User-Agent' header for the request.
+        c.setUserAgent(req)
+
+        // Set all headers.
+        for k, v := range metadata.customHeader {
+                req.Header.Set(k, v[0])
+        }
+
+        // Go net/http notoriously closes the request body.
+        // - The request Body, if non-nil, will be closed by the underlying Transport, even on errors.
+        // This can cause underlying *os.File seekers to fail, avoid that
+        // by making sure to wrap the closer as a nop.
+        if metadata.contentLength == 0 {
+                req.Body = nil
+        } else {
+                req.Body = io.NopCloser(metadata.contentBody)
+        }
+
+        // Set incoming content-length.
+        req.ContentLength = metadata.contentLength
+        if req.ContentLength <= -1 {
+                // For unknown content length, we upload using transfer-encoding: chunked.
+                req.TransferEncoding = []string{"chunked"}
+        }
+
+        // set md5Sum for content protection.
+        if len(metadata.contentMD5Base64) > 0 {
+                req.Header.Set("Content-Md5", metadata.contentMD5Base64)
+        }
+
+        // For anonymous requests just return.
+        if signerType.IsAnonymous() {
+                return req, nil
+        }
+
+        switch {
+        case signerType.IsV2():
+                // Add signature version '2' authorization header.
+                req = signer.SignV2(*req, accessKeyID, secretAccessKey, isVirtualHost)
+        case metadata.streamSha256 && !c.secure:
+                if len(metadata.trailer) > 0 {
+                        req.Trailer = metadata.trailer
+                }
+                // Streaming signature is used by default for a PUT object request.
+                // Additionally, we also look if the initialized client is secure,
+                // if yes then we don't need to perform streaming signature.
+                req = signer.StreamingSignV4(req, accessKeyID,
+                        secretAccessKey, sessionToken, location, metadata.contentLength, time.Now().UTC(), c.sha256Hasher())
+        default:
+                // Set sha256 sum for signature calculation only with signature version '4'.
+                shaHeader := unsignedPayload
+                if metadata.contentSHA256Hex != "" {
+                        shaHeader = metadata.contentSHA256Hex
+                        if len(metadata.trailer) > 0 {
+                                // Sanity check, we should not end up here if upstream is sane.
+                                return nil, errors.New("internal error: contentSHA256Hex with trailer not supported")
+                        }
+                } else if len(metadata.trailer) > 0 {
+                        shaHeader = unsignedPayloadTrailer
+                }
+                req.Header.Set("X-Amz-Content-Sha256", shaHeader)
+
+                // Add signature version '4' authorization header.
+                req = signer.SignV4Trailer(*req, accessKeyID, secretAccessKey, sessionToken, location, metadata.trailer)
+        }
+
+        // Return request.
+        return req, nil
+}
+
+// set User agent.
+func (c *Client) setUserAgent(req *http.Request) {
+        req.Header.Set("User-Agent", libraryUserAgent)
+        if c.appInfo.appName != "" && c.appInfo.appVersion != "" {
+                req.Header.Set("User-Agent", libraryUserAgent+" "+c.appInfo.appName+"/"+c.appInfo.appVersion)
+        }
+}
+
+// makeTargetURL make a new target url.
+func (c *Client) makeTargetURL(bucketName, objectName, bucketLocation string, isVirtualHostStyle bool, queryValues url.Values) (*url.URL, error) {
+        host := c.endpointURL.Host
+        // For Amazon S3 endpoint, try to fetch location based endpoint.
+        if s3utils.IsAmazonEndpoint(*c.endpointURL) {
+                if c.s3AccelerateEndpoint != "" && bucketName != "" {
+                        // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html
+                        // Disable transfer acceleration for non-compliant bucket names.
+                        if strings.Contains(bucketName, ".") {
+                                return nil, errTransferAccelerationBucket(bucketName)
+                        }
+                        // If transfer acceleration is requested set new host.
+                        // For more details about enabling transfer acceleration read here.
+                        // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html
+                        host = c.s3AccelerateEndpoint
+                } else {
+                        // Do not change the host if the endpoint URL is a FIPS S3 endpoint or a S3 PrivateLink interface endpoint
+                        if !s3utils.IsAmazonFIPSEndpoint(*c.endpointURL) && !s3utils.IsAmazonPrivateLinkEndpoint(*c.endpointURL) {
+                                // Fetch new host based on the bucket location.
+                                host = getS3Endpoint(bucketLocation)
+                        }
+                }
+        }
+
+        // Save scheme.
+        scheme := c.endpointURL.Scheme
+
+        // Strip port 80 and 443 so we won't send these ports in Host header.
+        // The reason is that browsers and curl automatically remove :80 and :443
+        // with the generated presigned urls, then a signature mismatch error.
+        if h, p, err := net.SplitHostPort(host); err == nil {
+                if scheme == "http" && p == "80" || scheme == "https" && p == "443" {
+                        host = h
+                        if ip := net.ParseIP(h); ip != nil && ip.To4() == nil {
+                                host = "[" + h + "]"
+                        }
+                }
+        }
+
+        urlStr := scheme + "://" + host + "/"
+
+        // Make URL only if bucketName is available, otherwise use the
+        // endpoint URL.
+        if bucketName != "" {
+                // If endpoint supports virtual host style use that always.
+                // Currently only S3 and Google Cloud Storage would support
+                // virtual host style.
+                if isVirtualHostStyle {
+                        urlStr = scheme + "://" + bucketName + "." + host + "/"
+                        if objectName != "" {
+                                urlStr += s3utils.EncodePath(objectName)
+                        }
+                } else {
+                        // If not fall back to using path style.
+                        urlStr = urlStr + bucketName + "/"
+                        if objectName != "" {
+                                urlStr += s3utils.EncodePath(objectName)
+                        }
+                }
+        }
+
+        // If there are any query values, add them to the end.
+        if len(queryValues) > 0 {
+                urlStr = urlStr + "?" + s3utils.QueryEncode(queryValues)
+        }
+
+        return url.Parse(urlStr)
+}
+
+// returns true if virtual hosted style requests are to be used.
+func (c *Client) isVirtualHostStyleRequest(url url.URL, bucketName string) bool {
+        if bucketName == "" {
+                return false
+        }
+
+        if c.lookup == BucketLookupDNS {
+                return true
+        }
+        if c.lookup == BucketLookupPath {
+                return false
+        }
+
+        // default to virtual only for Amazon/Google  storage. In all other cases use
+        // path style requests
+        return s3utils.IsVirtualHostSupported(url, bucketName)
+}
diff --git a/vendor/github.com/minio/minio-go/v7/bucket-cache.go b/vendor/github.com/minio/minio-go/v7/bucket-cache.go
new file mode 100644
index 0000000..b1d3b38
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/bucket-cache.go
@@ -0,0 +1,256 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 minio
+
+import (
+        "context"
+        "net"
+        "net/http"
+        "net/url"
+        "path"
+        "sync"
+
+        "github.com/minio/minio-go/v7/pkg/credentials"
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+        "github.com/minio/minio-go/v7/pkg/signer"
+)
+
+// bucketLocationCache - Provides simple mechanism to hold bucket
+// locations in memory.
+type bucketLocationCache struct {
+        // mutex is used for handling the concurrent
+        // read/write requests for cache.
+        sync.RWMutex
+
+        // items holds the cached bucket locations.
+        items map[string]string
+}
+
+// newBucketLocationCache - Provides a new bucket location cache to be
+// used internally with the client object.
+func newBucketLocationCache() *bucketLocationCache {
+        return &bucketLocationCache{
+                items: make(map[string]string),
+        }
+}
+
+// Get - Returns a value of a given key if it exists.
+func (r *bucketLocationCache) Get(bucketName string) (location string, ok bool) {
+        r.RLock()
+        defer r.RUnlock()
+        location, ok = r.items[bucketName]
+        return
+}
+
+// Set - Will persist a value into cache.
+func (r *bucketLocationCache) Set(bucketName, location string) {
+        r.Lock()
+        defer r.Unlock()
+        r.items[bucketName] = location
+}
+
+// Delete - Deletes a bucket name from cache.
+func (r *bucketLocationCache) Delete(bucketName string) {
+        r.Lock()
+        defer r.Unlock()
+        delete(r.items, bucketName)
+}
+
+// GetBucketLocation - get location for the bucket name from location cache, if not
+// fetch freshly by making a new request.
+func (c *Client) GetBucketLocation(ctx context.Context, bucketName string) (string, error) {
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return "", err
+        }
+        return c.getBucketLocation(ctx, bucketName)
+}
+
+// getBucketLocation - Get location for the bucketName from location map cache, if not
+// fetch freshly by making a new request.
+func (c *Client) getBucketLocation(ctx context.Context, bucketName string) (string, error) {
+        if err := s3utils.CheckValidBucketName(bucketName); err != nil {
+                return "", err
+        }
+
+        // Region set then no need to fetch bucket location.
+        if c.region != "" {
+                return c.region, nil
+        }
+
+        if location, ok := c.bucketLocCache.Get(bucketName); ok {
+                return location, nil
+        }
+
+        // Initialize a new request.
+        req, err := c.getBucketLocationRequest(ctx, bucketName)
+        if err != nil {
+                return "", err
+        }
+
+        // Initiate the request.
+        resp, err := c.do(req)
+        defer closeResponse(resp)
+        if err != nil {
+                return "", err
+        }
+        location, err := processBucketLocationResponse(resp, bucketName)
+        if err != nil {
+                return "", err
+        }
+        c.bucketLocCache.Set(bucketName, location)
+        return location, nil
+}
+
+// processes the getBucketLocation http response from the server.
+func processBucketLocationResponse(resp *http.Response, bucketName string) (bucketLocation string, err error) {
+        if resp != nil {
+                if resp.StatusCode != http.StatusOK {
+                        err = httpRespToErrorResponse(resp, bucketName, "")
+                        errResp := ToErrorResponse(err)
+                        // For access denied error, it could be an anonymous
+                        // request. Move forward and let the top level callers
+                        // succeed if possible based on their policy.
+                        switch errResp.Code {
+                        case "NotImplemented":
+                                switch errResp.Server {
+                                case "AmazonSnowball":
+                                        return "snowball", nil
+                                case "cloudflare":
+                                        return "us-east-1", nil
+                                }
+                        case "AuthorizationHeaderMalformed":
+                                fallthrough
+                        case "InvalidRegion":
+                                fallthrough
+                        case "AccessDenied":
+                                if errResp.Region == "" {
+                                        return "us-east-1", nil
+                                }
+                                return errResp.Region, nil
+                        }
+                        return "", err
+                }
+        }
+
+        // Extract location.
+        var locationConstraint string
+        err = xmlDecoder(resp.Body, &locationConstraint)
+        if err != nil {
+                return "", err
+        }
+
+        location := locationConstraint
+        // Location is empty will be 'us-east-1'.
+        if location == "" {
+                location = "us-east-1"
+        }
+
+        // Location can be 'EU' convert it to meaningful 'eu-west-1'.
+        if location == "EU" {
+                location = "eu-west-1"
+        }
+
+        // Save the location into cache.
+
+        // Return.
+        return location, nil
+}
+
+// getBucketLocationRequest - Wrapper creates a new getBucketLocation request.
+func (c *Client) getBucketLocationRequest(ctx context.Context, bucketName string) (*http.Request, error) {
+        // Set location query.
+        urlValues := make(url.Values)
+        urlValues.Set("location", "")
+
+        // Set get bucket location always as path style.
+        targetURL := *c.endpointURL
+
+        // as it works in makeTargetURL method from api.go file
+        if h, p, err := net.SplitHostPort(targetURL.Host); err == nil {
+                if targetURL.Scheme == "http" && p == "80" || targetURL.Scheme == "https" && p == "443" {
+                        targetURL.Host = h
+                        if ip := net.ParseIP(h); ip != nil && ip.To16() != nil {
+                                targetURL.Host = "[" + h + "]"
+                        }
+                }
+        }
+
+        isVirtualStyle := c.isVirtualHostStyleRequest(targetURL, bucketName)
+
+        var urlStr string
+
+        if isVirtualStyle {
+                urlStr = c.endpointURL.Scheme + "://" + bucketName + "." + targetURL.Host + "/?location"
+        } else {
+                targetURL.Path = path.Join(bucketName, "") + "/"
+                targetURL.RawQuery = urlValues.Encode()
+                urlStr = targetURL.String()
+        }
+
+        // Get a new HTTP request for the method.
+        req, err := http.NewRequestWithContext(ctx, http.MethodGet, urlStr, nil)
+        if err != nil {
+                return nil, err
+        }
+
+        // Set UserAgent for the request.
+        c.setUserAgent(req)
+
+        // Get credentials from the configured credentials provider.
+        value, err := c.credsProvider.Get()
+        if err != nil {
+                return nil, err
+        }
+
+        var (
+                signerType      = value.SignerType
+                accessKeyID     = value.AccessKeyID
+                secretAccessKey = value.SecretAccessKey
+                sessionToken    = value.SessionToken
+        )
+
+        // Custom signer set then override the behavior.
+        if c.overrideSignerType != credentials.SignatureDefault {
+                signerType = c.overrideSignerType
+        }
+
+        // If signerType returned by credentials helper is anonymous,
+        // then do not sign regardless of signerType override.
+        if value.SignerType == credentials.SignatureAnonymous {
+                signerType = credentials.SignatureAnonymous
+        }
+
+        if signerType.IsAnonymous() {
+                return req, nil
+        }
+
+        if signerType.IsV2() {
+                req = signer.SignV2(*req, accessKeyID, secretAccessKey, isVirtualStyle)
+                return req, nil
+        }
+
+        // Set sha256 sum for signature calculation only with signature version '4'.
+        contentSha256 := emptySHA256Hex
+        if c.secure {
+                contentSha256 = unsignedPayload
+        }
+
+        req.Header.Set("X-Amz-Content-Sha256", contentSha256)
+        req = signer.SignV4(*req, accessKeyID, secretAccessKey, sessionToken, "us-east-1")
+        return req, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/checksum.go b/vendor/github.com/minio/minio-go/v7/checksum.go
new file mode 100644
index 0000000..a1f6f43
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/checksum.go
@@ -0,0 +1,210 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2023 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 minio
+
+import (
+        "crypto/sha1"
+        "crypto/sha256"
+        "encoding/base64"
+        "hash"
+        "hash/crc32"
+        "io"
+        "math/bits"
+)
+
+// ChecksumType contains information about the checksum type.
+type ChecksumType uint32
+
+const (
+
+        // ChecksumSHA256 indicates a SHA256 checksum.
+        ChecksumSHA256 ChecksumType = 1 << iota
+        // ChecksumSHA1 indicates a SHA-1 checksum.
+        ChecksumSHA1
+        // ChecksumCRC32 indicates a CRC32 checksum with IEEE table.
+        ChecksumCRC32
+        // ChecksumCRC32C indicates a CRC32 checksum with Castagnoli table.
+        ChecksumCRC32C
+
+        // Keep after all valid checksums
+        checksumLast
+
+        // checksumMask is a mask for valid checksum types.
+        checksumMask = checksumLast - 1
+
+        // ChecksumNone indicates no checksum.
+        ChecksumNone ChecksumType = 0
+
+        amzChecksumAlgo   = "x-amz-checksum-algorithm"
+        amzChecksumCRC32  = "x-amz-checksum-crc32"
+        amzChecksumCRC32C = "x-amz-checksum-crc32c"
+        amzChecksumSHA1   = "x-amz-checksum-sha1"
+        amzChecksumSHA256 = "x-amz-checksum-sha256"
+)
+
+// Is returns if c is all of t.
+func (c ChecksumType) Is(t ChecksumType) bool {
+        return c&t == t
+}
+
+// Key returns the header key.
+// returns empty string if invalid or none.
+func (c ChecksumType) Key() string {
+        switch c & checksumMask {
+        case ChecksumCRC32:
+                return amzChecksumCRC32
+        case ChecksumCRC32C:
+                return amzChecksumCRC32C
+        case ChecksumSHA1:
+                return amzChecksumSHA1
+        case ChecksumSHA256:
+                return amzChecksumSHA256
+        }
+        return ""
+}
+
+// RawByteLen returns the size of the un-encoded checksum.
+func (c ChecksumType) RawByteLen() int {
+        switch c & checksumMask {
+        case ChecksumCRC32, ChecksumCRC32C:
+                return 4
+        case ChecksumSHA1:
+                return sha1.Size
+        case ChecksumSHA256:
+                return sha256.Size
+        }
+        return 0
+}
+
+// Hasher returns a hasher corresponding to the checksum type.
+// Returns nil if no checksum.
+func (c ChecksumType) Hasher() hash.Hash {
+        switch c & checksumMask {
+        case ChecksumCRC32:
+                return crc32.NewIEEE()
+        case ChecksumCRC32C:
+                return crc32.New(crc32.MakeTable(crc32.Castagnoli))
+        case ChecksumSHA1:
+                return sha1.New()
+        case ChecksumSHA256:
+                return sha256.New()
+        }
+        return nil
+}
+
+// IsSet returns whether the type is valid and known.
+func (c ChecksumType) IsSet() bool {
+        return bits.OnesCount32(uint32(c)) == 1
+}
+
+// String returns the type as a string.
+// CRC32, CRC32C, SHA1, and SHA256 for valid values.
+// Empty string for unset and "<invalid>" if not valid.
+func (c ChecksumType) String() string {
+        switch c & checksumMask {
+        case ChecksumCRC32:
+                return "CRC32"
+        case ChecksumCRC32C:
+                return "CRC32C"
+        case ChecksumSHA1:
+                return "SHA1"
+        case ChecksumSHA256:
+                return "SHA256"
+        case ChecksumNone:
+                return ""
+        }
+        return "<invalid>"
+}
+
+// ChecksumReader reads all of r and returns a checksum of type c.
+// Returns any error that may have occurred while reading.
+func (c ChecksumType) ChecksumReader(r io.Reader) (Checksum, error) {
+        h := c.Hasher()
+        if h == nil {
+                return Checksum{}, nil
+        }
+        _, err := io.Copy(h, r)
+        if err != nil {
+                return Checksum{}, err
+        }
+        return NewChecksum(c, h.Sum(nil)), nil
+}
+
+// ChecksumBytes returns a checksum of the content b with type c.
+func (c ChecksumType) ChecksumBytes(b []byte) Checksum {
+        h := c.Hasher()
+        if h == nil {
+                return Checksum{}
+        }
+        n, err := h.Write(b)
+        if err != nil || n != len(b) {
+                // Shouldn't happen with these checksummers.
+                return Checksum{}
+        }
+        return NewChecksum(c, h.Sum(nil))
+}
+
+// Checksum is a type and encoded value.
+type Checksum struct {
+        Type ChecksumType
+        r    []byte
+}
+
+// NewChecksum sets the checksum to the value of b,
+// which is the raw hash output.
+// If the length of c does not match t.RawByteLen,
+// a checksum with ChecksumNone is returned.
+func NewChecksum(t ChecksumType, b []byte) Checksum {
+        if t.IsSet() && len(b) == t.RawByteLen() {
+                return Checksum{Type: t, r: b}
+        }
+        return Checksum{}
+}
+
+// NewChecksumString sets the checksum to the value of s,
+// which is the base 64 encoded raw hash output.
+// If the length of c does not match t.RawByteLen, it is not added.
+func NewChecksumString(t ChecksumType, s string) Checksum {
+        b, _ := base64.StdEncoding.DecodeString(s)
+        if t.IsSet() && len(b) == t.RawByteLen() {
+                return Checksum{Type: t, r: b}
+        }
+        return Checksum{}
+}
+
+// IsSet returns whether the checksum is valid and known.
+func (c Checksum) IsSet() bool {
+        return c.Type.IsSet() && len(c.r) == c.Type.RawByteLen()
+}
+
+// Encoded returns the encoded value.
+// Returns the empty string if not set or valid.
+func (c Checksum) Encoded() string {
+        if !c.IsSet() {
+                return ""
+        }
+        return base64.StdEncoding.EncodeToString(c.r)
+}
+
+// Raw returns the raw checksum value if set.
+func (c Checksum) Raw() []byte {
+        if !c.IsSet() {
+                return nil
+        }
+        return c.r
+}
diff --git a/vendor/github.com/minio/minio-go/v7/code_of_conduct.md b/vendor/github.com/minio/minio-go/v7/code_of_conduct.md
new file mode 100644
index 0000000..cb232c3
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/code_of_conduct.md
@@ -0,0 +1,80 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior, in compliance with the
+licensing terms applying to the Project developments.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful. However, these actions shall respect the
+licensing terms of the Project Developments that will always supersede such
+Code of Conduct.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at [email protected]. The project team
+will review and investigate all complaints, and will respond in a way that it deems
+appropriate to the circumstances. The project team is obligated to maintain
+confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+This version includes a clarification to ensure that the code of conduct is in
+compliance with the free software licensing terms of the project.
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/
diff --git a/vendor/github.com/minio/minio-go/v7/constants.go b/vendor/github.com/minio/minio-go/v7/constants.go
new file mode 100644
index 0000000..401d2a7
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/constants.go
@@ -0,0 +1,110 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 minio
+
+// Multipart upload defaults.
+
+// absMinPartSize - absolute minimum part size (5 MiB) below which
+// a part in a multipart upload may not be uploaded.
+const absMinPartSize = 1024 * 1024 * 5
+
+// minPartSize - minimum part size 16MiB per object after which
+// putObject behaves internally as multipart.
+const minPartSize = 1024 * 1024 * 16
+
+// maxPartsCount - maximum number of parts for a single multipart session.
+const maxPartsCount = 10000
+
+// maxPartSize - maximum part size 5GiB for a single multipart upload
+// operation.
+const maxPartSize = 1024 * 1024 * 1024 * 5
+
+// maxSinglePutObjectSize - maximum size 5GiB of object per PUT
+// operation.
+const maxSinglePutObjectSize = 1024 * 1024 * 1024 * 5
+
+// maxMultipartPutObjectSize - maximum size 5TiB of object for
+// Multipart operation.
+const maxMultipartPutObjectSize = 1024 * 1024 * 1024 * 1024 * 5
+
+// unsignedPayload - value to be set to X-Amz-Content-Sha256 header when
+// we don't want to sign the request payload
+const unsignedPayload = "UNSIGNED-PAYLOAD"
+
+// unsignedPayloadTrailer value to be set to X-Amz-Content-Sha256 header when
+// we don't want to sign the request payload, but have a trailer.
+const unsignedPayloadTrailer = "STREAMING-UNSIGNED-PAYLOAD-TRAILER"
+
+// Total number of parallel workers used for multipart operation.
+const totalWorkers = 4
+
+// Signature related constants.
+const (
+        signV4Algorithm   = "AWS4-HMAC-SHA256"
+        iso8601DateFormat = "20060102T150405Z"
+)
+
+const (
+        // Storage class header.
+        amzStorageClass = "X-Amz-Storage-Class"
+
+        // Website redirect location header
+        amzWebsiteRedirectLocation = "X-Amz-Website-Redirect-Location"
+
+        // Object Tagging headers
+        amzTaggingHeader          = "X-Amz-Tagging"
+        amzTaggingHeaderDirective = "X-Amz-Tagging-Directive"
+
+        amzVersionID         = "X-Amz-Version-Id"
+        amzTaggingCount      = "X-Amz-Tagging-Count"
+        amzExpiration        = "X-Amz-Expiration"
+        amzRestore           = "X-Amz-Restore"
+        amzReplicationStatus = "X-Amz-Replication-Status"
+        amzDeleteMarker      = "X-Amz-Delete-Marker"
+
+        // Object legal hold header
+        amzLegalHoldHeader = "X-Amz-Object-Lock-Legal-Hold"
+
+        // Object retention header
+        amzLockMode         = "X-Amz-Object-Lock-Mode"
+        amzLockRetainUntil  = "X-Amz-Object-Lock-Retain-Until-Date"
+        amzBypassGovernance = "X-Amz-Bypass-Governance-Retention"
+
+        // Replication status
+        amzBucketReplicationStatus = "X-Amz-Replication-Status"
+        // Minio specific Replication/lifecycle transition extension
+        minIOBucketSourceMTime = "X-Minio-Source-Mtime"
+
+        minIOBucketSourceETag              = "X-Minio-Source-Etag"
+        minIOBucketReplicationDeleteMarker = "X-Minio-Source-DeleteMarker"
+        minIOBucketReplicationProxyRequest = "X-Minio-Source-Proxy-Request"
+        minIOBucketReplicationRequest      = "X-Minio-Source-Replication-Request"
+        minIOBucketReplicationCheck        = "X-Minio-Source-Replication-Check"
+
+        // Header indicates last tag update time on source
+        minIOBucketReplicationTaggingTimestamp = "X-Minio-Source-Replication-Tagging-Timestamp"
+        // Header indicates last retention update time on source
+        minIOBucketReplicationObjectRetentionTimestamp = "X-Minio-Source-Replication-Retention-Timestamp"
+        // Header indicates last legalhold update time on source
+        minIOBucketReplicationObjectLegalHoldTimestamp = "X-Minio-Source-Replication-LegalHold-Timestamp"
+        minIOForceDelete                               = "x-minio-force-delete"
+        // Header indicates delete marker replication request can be sent by source now.
+        minioTgtReplicationReady = "X-Minio-Replication-Ready"
+        // Header asks if delete marker replication request can be sent by source now.
+        isMinioTgtReplicationReady = "X-Minio-Check-Replication-Ready"
+)
diff --git a/vendor/github.com/minio/minio-go/v7/core.go b/vendor/github.com/minio/minio-go/v7/core.go
new file mode 100644
index 0000000..132ea70
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/core.go
@@ -0,0 +1,150 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 minio
+
+import (
+        "context"
+        "io"
+        "net/http"
+
+        "github.com/minio/minio-go/v7/pkg/encrypt"
+)
+
+// Core - Inherits Client and adds new methods to expose the low level S3 APIs.
+type Core struct {
+        *Client
+}
+
+// NewCore - Returns new initialized a Core client, this CoreClient should be
+// only used under special conditions such as need to access lower primitives
+// and being able to use them to write your own wrappers.
+func NewCore(endpoint string, opts *Options) (*Core, error) {
+        var s3Client Core
+        client, err := New(endpoint, opts)
+        if err != nil {
+                return nil, err
+        }
+        s3Client.Client = client
+        return &s3Client, nil
+}
+
+// ListObjects - List all the objects at a prefix, optionally with marker and delimiter
+// you can further filter the results.
+func (c Core) ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (result ListBucketResult, err error) {
+        return c.listObjectsQuery(context.Background(), bucket, prefix, marker, delimiter, maxKeys, nil)
+}
+
+// ListObjectsV2 - Lists all the objects at a prefix, similar to ListObjects() but uses
+// continuationToken instead of marker to support iteration over the results.
+func (c Core) ListObjectsV2(bucketName, objectPrefix, startAfter, continuationToken, delimiter string, maxkeys int) (ListBucketV2Result, error) {
+        return c.listObjectsV2Query(context.Background(), bucketName, objectPrefix, continuationToken, true, false, delimiter, startAfter, maxkeys, nil)
+}
+
+// CopyObject - copies an object from source object to destination object on server side.
+func (c Core) CopyObject(ctx context.Context, sourceBucket, sourceObject, destBucket, destObject string, metadata map[string]string, srcOpts CopySrcOptions, dstOpts PutObjectOptions) (ObjectInfo, error) {
+        return c.copyObjectDo(ctx, sourceBucket, sourceObject, destBucket, destObject, metadata, srcOpts, dstOpts)
+}
+
+// CopyObjectPart - creates a part in a multipart upload by copying (a
+// part of) an existing object.
+func (c Core) CopyObjectPart(ctx context.Context, srcBucket, srcObject, destBucket, destObject, uploadID string,
+        partID int, startOffset, length int64, metadata map[string]string,
+) (p CompletePart, err error) {
+        return c.copyObjectPartDo(ctx, srcBucket, srcObject, destBucket, destObject, uploadID,
+                partID, startOffset, length, metadata)
+}
+
+// PutObject - Upload object. Uploads using single PUT call.
+func (c Core) PutObject(ctx context.Context, bucket, object string, data io.Reader, size int64, md5Base64, sha256Hex string, opts PutObjectOptions) (UploadInfo, error) {
+        hookReader := newHook(data, opts.Progress)
+        return c.putObjectDo(ctx, bucket, object, hookReader, md5Base64, sha256Hex, size, opts)
+}
+
+// NewMultipartUpload - Initiates new multipart upload and returns the new uploadID.
+func (c Core) NewMultipartUpload(ctx context.Context, bucket, object string, opts PutObjectOptions) (uploadID string, err error) {
+        result, err := c.initiateMultipartUpload(ctx, bucket, object, opts)
+        return result.UploadID, err
+}
+
+// ListMultipartUploads - List incomplete uploads.
+func (c Core) ListMultipartUploads(ctx context.Context, bucket, prefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (result ListMultipartUploadsResult, err error) {
+        return c.listMultipartUploadsQuery(ctx, bucket, keyMarker, uploadIDMarker, prefix, delimiter, maxUploads)
+}
+
+// PutObjectPartOptions contains options for PutObjectPart API
+type PutObjectPartOptions struct {
+        Md5Base64, Sha256Hex  string
+        SSE                   encrypt.ServerSide
+        CustomHeader, Trailer http.Header
+}
+
+// PutObjectPart - Upload an object part.
+func (c Core) PutObjectPart(ctx context.Context, bucket, object, uploadID string, partID int,
+        data io.Reader, size int64, opts PutObjectPartOptions,
+) (ObjectPart, error) {
+        p := uploadPartParams{
+                bucketName:   bucket,
+                objectName:   object,
+                uploadID:     uploadID,
+                reader:       data,
+                partNumber:   partID,
+                md5Base64:    opts.Md5Base64,
+                sha256Hex:    opts.Sha256Hex,
+                size:         size,
+                sse:          opts.SSE,
+                streamSha256: true,
+                customHeader: opts.CustomHeader,
+                trailer:      opts.Trailer,
+        }
+        return c.uploadPart(ctx, p)
+}
+
+// ListObjectParts - List uploaded parts of an incomplete upload.x
+func (c Core) ListObjectParts(ctx context.Context, bucket, object, uploadID string, partNumberMarker, maxParts int) (result ListObjectPartsResult, err error) {
+        return c.listObjectPartsQuery(ctx, bucket, object, uploadID, partNumberMarker, maxParts)
+}
+
+// CompleteMultipartUpload - Concatenate uploaded parts and commit to an object.
+func (c Core) CompleteMultipartUpload(ctx context.Context, bucket, object, uploadID string, parts []CompletePart, opts PutObjectOptions) (UploadInfo, error) {
+        res, err := c.completeMultipartUpload(ctx, bucket, object, uploadID, completeMultipartUpload{
+                Parts: parts,
+        }, opts)
+        return res, err
+}
+
+// AbortMultipartUpload - Abort an incomplete upload.
+func (c Core) AbortMultipartUpload(ctx context.Context, bucket, object, uploadID string) error {
+        return c.abortMultipartUpload(ctx, bucket, object, uploadID)
+}
+
+// GetBucketPolicy - fetches bucket access policy for a given bucket.
+func (c Core) GetBucketPolicy(ctx context.Context, bucket string) (string, error) {
+        return c.getBucketPolicy(ctx, bucket)
+}
+
+// PutBucketPolicy - applies a new bucket access policy for a given bucket.
+func (c Core) PutBucketPolicy(ctx context.Context, bucket, bucketPolicy string) error {
+        return c.putBucketPolicy(ctx, bucket, bucketPolicy)
+}
+
+// GetObject is a lower level API implemented to support reading
+// partial objects and also downloading objects with special conditions
+// matching etag, modtime etc.
+func (c Core) GetObject(ctx context.Context, bucketName, objectName string, opts GetObjectOptions) (io.ReadCloser, ObjectInfo, http.Header, error) {
+        return c.getObject(ctx, bucketName, objectName, opts)
+}
diff --git a/vendor/github.com/minio/minio-go/v7/functional_tests.go b/vendor/github.com/minio/minio-go/v7/functional_tests.go
new file mode 100644
index 0000000..f951cd0
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/functional_tests.go
@@ -0,0 +1,13004 @@
+//go:build mint
+// +build mint
+
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2020 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 main
+
+import (
+        "archive/zip"
+        "bytes"
+        "context"
+        "crypto/sha1"
+        "encoding/base64"
+        "errors"
+        "fmt"
+        "hash"
+        "hash/crc32"
+        "io"
+        "math/rand"
+        "mime/multipart"
+        "net/http"
+        "net/url"
+        "os"
+        "path"
+        "path/filepath"
+        "reflect"
+        "runtime"
+        "sort"
+        "strconv"
+        "strings"
+        "sync"
+        "time"
+
+        "github.com/dustin/go-humanize"
+        jsoniter "github.com/json-iterator/go"
+        "github.com/minio/sha256-simd"
+        log "github.com/sirupsen/logrus"
+
+        "github.com/minio/minio-go/v7"
+        "github.com/minio/minio-go/v7/pkg/credentials"
+        "github.com/minio/minio-go/v7/pkg/encrypt"
+        "github.com/minio/minio-go/v7/pkg/notification"
+        "github.com/minio/minio-go/v7/pkg/tags"
+)
+
+const letterBytes = "abcdefghijklmnopqrstuvwxyz01234569"
+const (
+        letterIdxBits = 6                    // 6 bits to represent a letter index
+        letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
+        letterIdxMax  = 63 / letterIdxBits   // # of letter indices fitting in 63 bits
+)
+
+const (
+        serverEndpoint = "SERVER_ENDPOINT"
+        accessKey      = "ACCESS_KEY"
+        secretKey      = "SECRET_KEY"
+        enableHTTPS    = "ENABLE_HTTPS"
+        enableKMS      = "ENABLE_KMS"
+)
+
+type mintJSONFormatter struct{}
+
+func (f *mintJSONFormatter) Format(entry *log.Entry) ([]byte, error) {
+        data := make(log.Fields, len(entry.Data))
+        for k, v := range entry.Data {
+                switch v := v.(type) {
+                case error:
+                        // Otherwise errors are ignored by `encoding/json`
+                        // https://github.com/sirupsen/logrus/issues/137
+                        data[k] = v.Error()
+                default:
+                        data[k] = v
+                }
+        }
+        json := jsoniter.ConfigCompatibleWithStandardLibrary
+        serialized, err := json.Marshal(data)
+        if err != nil {
+                return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
+        }
+        return append(serialized, '\n'), nil
+}
+
+var readFull = func(r io.Reader, buf []byte) (n int, err error) {
+        // ReadFull reads exactly len(buf) bytes from r into buf.
+        // It returns the number of bytes copied and an error if
+        // fewer bytes were read. The error is EOF only if no bytes
+        // were read. If an EOF happens after reading some but not
+        // all the bytes, ReadFull returns ErrUnexpectedEOF.
+        // On return, n == len(buf) if and only if err == nil.
+        // If r returns an error having read at least len(buf) bytes,
+        // the error is dropped.
+        for n < len(buf) && err == nil {
+                var nn int
+                nn, err = r.Read(buf[n:])
+                // Some spurious io.Reader's return
+                // io.ErrUnexpectedEOF when nn == 0
+                // this behavior is undocumented
+                // so we are on purpose not using io.ReadFull
+                // implementation because this can lead
+                // to custom handling, to avoid that
+                // we simply modify the original io.ReadFull
+                // implementation to avoid this issue.
+                // io.ErrUnexpectedEOF with nn == 0 really
+                // means that io.EOF
+                if err == io.ErrUnexpectedEOF && nn == 0 {
+                        err = io.EOF
+                }
+                n += nn
+        }
+        if n >= len(buf) {
+                err = nil
+        } else if n > 0 && err == io.EOF {
+                err = io.ErrUnexpectedEOF
+        }
+        return
+}
+
+func cleanEmptyEntries(fields log.Fields) log.Fields {
+        cleanFields := log.Fields{}
+        for k, v := range fields {
+                if v != "" {
+                        cleanFields[k] = v
+                }
+        }
+        return cleanFields
+}
+
+// log successful test runs
+func successLogger(testName, function string, args map[string]interface{}, startTime time.Time) *log.Entry {
+        // calculate the test case duration
+        duration := time.Since(startTime)
+        // log with the fields as per mint
+        fields := log.Fields{"name": "minio-go: " + testName, "function": function, "args": args, "duration": duration.Nanoseconds() / 1000000, "status": "PASS"}
+        return log.WithFields(cleanEmptyEntries(fields))
+}
+
+// As few of the features are not available in Gateway(s) currently, Check if err value is NotImplemented,
+// and log as NA in that case and continue execution. Otherwise log as failure and return
+func logError(testName, function string, args map[string]interface{}, startTime time.Time, alert, message string, err error) {
+        // If server returns NotImplemented we assume it is gateway mode and hence log it as info and move on to next tests
+        // Special case for ComposeObject API as it is implemented on client side and adds specific error details like `Error in upload-part-copy` in
+        // addition to NotImplemented error returned from server
+        if isErrNotImplemented(err) {
+                ignoredLog(testName, function, args, startTime, message).Info()
+        } else if isRunOnFail() {
+                failureLog(testName, function, args, startTime, alert, message, err).Error()
+        } else {
+                failureLog(testName, function, args, startTime, alert, message, err).Fatal()
+        }
+}
+
+// log failed test runs
+func failureLog(testName, function string, args map[string]interface{}, startTime time.Time, alert, message string, err error) *log.Entry {
+        // calculate the test case duration
+        duration := time.Since(startTime)
+        var fields log.Fields
+        // log with the fields as per mint
+        if err != nil {
+                fields = log.Fields{
+                        "name": "minio-go: " + testName, "function": function, "args": args,
+                        "duration": duration.Nanoseconds() / 1000000, "status": "FAIL", "alert": alert, "message": message, "error": err,
+                }
+        } else {
+                fields = log.Fields{
+                        "name": "minio-go: " + testName, "function": function, "args": args,
+                        "duration": duration.Nanoseconds() / 1000000, "status": "FAIL", "alert": alert, "message": message,
+                }
+        }
+        return log.WithFields(cleanEmptyEntries(fields))
+}
+
+// log not applicable test runs
+func ignoredLog(testName, function string, args map[string]interface{}, startTime time.Time, alert string) *log.Entry {
+        // calculate the test case duration
+        duration := time.Since(startTime)
+        // log with the fields as per mint
+        fields := log.Fields{
+                "name": "minio-go: " + testName, "function": function, "args": args,
+                "duration": duration.Nanoseconds() / 1000000, "status": "NA", "alert": strings.Split(alert, " ")[0] + " is NotImplemented",
+        }
+        return log.WithFields(cleanEmptyEntries(fields))
+}
+
+// Delete objects in given bucket, recursively
+func cleanupBucket(bucketName string, c *minio.Client) error {
+        // Create a done channel to control 'ListObjectsV2' go routine.
+        doneCh := make(chan struct{})
+        // Exit cleanly upon return.
+        defer close(doneCh)
+        // Iterate over all objects in the bucket via listObjectsV2 and delete
+        for objCh := range c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{Recursive: true}) {
+                if objCh.Err != nil {
+                        return objCh.Err
+                }
+                if objCh.Key != "" {
+                        err := c.RemoveObject(context.Background(), bucketName, objCh.Key, minio.RemoveObjectOptions{})
+                        if err != nil {
+                                return err
+                        }
+                }
+        }
+        for objPartInfo := range c.ListIncompleteUploads(context.Background(), bucketName, "", true) {
+                if objPartInfo.Err != nil {
+                        return objPartInfo.Err
+                }
+                if objPartInfo.Key != "" {
+                        err := c.RemoveIncompleteUpload(context.Background(), bucketName, objPartInfo.Key)
+                        if err != nil {
+                                return err
+                        }
+                }
+        }
+        // objects are already deleted, clear the buckets now
+        err := c.RemoveBucket(context.Background(), bucketName)
+        if err != nil {
+                return err
+        }
+        return err
+}
+
+func cleanupVersionedBucket(bucketName string, c *minio.Client) error {
+        doneCh := make(chan struct{})
+        defer close(doneCh)
+        for obj := range c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: true}) {
+                if obj.Err != nil {
+                        return obj.Err
+                }
+                if obj.Key != "" {
+                        err := c.RemoveObject(context.Background(), bucketName, obj.Key,
+                                minio.RemoveObjectOptions{VersionID: obj.VersionID, GovernanceBypass: true})
+                        if err != nil {
+                                return err
+                        }
+                }
+        }
+        for objPartInfo := range c.ListIncompleteUploads(context.Background(), bucketName, "", true) {
+                if objPartInfo.Err != nil {
+                        return objPartInfo.Err
+                }
+                if objPartInfo.Key != "" {
+                        err := c.RemoveIncompleteUpload(context.Background(), bucketName, objPartInfo.Key)
+                        if err != nil {
+                                return err
+                        }
+                }
+        }
+        // objects are already deleted, clear the buckets now
+        err := c.RemoveBucket(context.Background(), bucketName)
+        if err != nil {
+                for obj := range c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: true}) {
+                        log.Println("found", obj.Key, obj.VersionID)
+                }
+                return err
+        }
+        return err
+}
+
+func isErrNotImplemented(err error) bool {
+        return minio.ToErrorResponse(err).Code == "NotImplemented"
+}
+
+func isRunOnFail() bool {
+        return os.Getenv("RUN_ON_FAIL") == "1"
+}
+
+func init() {
+        // If server endpoint is not set, all tests default to
+        // using https://play.min.io
+        if os.Getenv(serverEndpoint) == "" {
+                os.Setenv(serverEndpoint, "play.min.io")
+                os.Setenv(accessKey, "Q3AM3UQ867SPQQA43P2F")
+                os.Setenv(secretKey, "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG")
+                os.Setenv(enableHTTPS, "1")
+        }
+}
+
+var mintDataDir = os.Getenv("MINT_DATA_DIR")
+
+func getMintDataDirFilePath(filename string) (fp string) {
+        if mintDataDir == "" {
+                return
+        }
+        return filepath.Join(mintDataDir, filename)
+}
+
+func newRandomReader(seed, size int64) io.Reader {
+        return io.LimitReader(rand.New(rand.NewSource(seed)), size)
+}
+
+func mustCrcReader(r io.Reader) uint32 {
+        crc := crc32.NewIEEE()
+        _, err := io.Copy(crc, r)
+        if err != nil {
+                panic(err)
+        }
+        return crc.Sum32()
+}
+
+func crcMatches(r io.Reader, want uint32) error {
+        crc := crc32.NewIEEE()
+        _, err := io.Copy(crc, r)
+        if err != nil {
+                panic(err)
+        }
+        got := crc.Sum32()
+        if got != want {
+                return fmt.Errorf("crc mismatch, want %x, got %x", want, got)
+        }
+        return nil
+}
+
+func crcMatchesName(r io.Reader, name string) error {
+        want := dataFileCRC32[name]
+        crc := crc32.NewIEEE()
+        _, err := io.Copy(crc, r)
+        if err != nil {
+                panic(err)
+        }
+        got := crc.Sum32()
+        if got != want {
+                return fmt.Errorf("crc mismatch, want %x, got %x", want, got)
+        }
+        return nil
+}
+
+// read data from file if it exists or optionally create a buffer of particular size
+func getDataReader(fileName string) io.ReadCloser {
+        if mintDataDir == "" {
+                size := int64(dataFileMap[fileName])
+                if _, ok := dataFileCRC32[fileName]; !ok {
+                        dataFileCRC32[fileName] = mustCrcReader(newRandomReader(size, size))
+                }
+                return io.NopCloser(newRandomReader(size, size))
+        }
+        reader, _ := os.Open(getMintDataDirFilePath(fileName))
+        if _, ok := dataFileCRC32[fileName]; !ok {
+                dataFileCRC32[fileName] = mustCrcReader(reader)
+                reader.Close()
+                reader, _ = os.Open(getMintDataDirFilePath(fileName))
+        }
+        return reader
+}
+
+// randString generates random names and prepends them with a known prefix.
+func randString(n int, src rand.Source, prefix string) string {
+        b := make([]byte, n)
+        // A rand.Int63() generates 63 random bits, enough for letterIdxMax letters!
+        for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
+                if remain == 0 {
+                        cache, remain = src.Int63(), letterIdxMax
+                }
+                if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
+                        b[i] = letterBytes[idx]
+                        i--
+                }
+                cache >>= letterIdxBits
+                remain--
+        }
+        return prefix + string(b[0:30-len(prefix)])
+}
+
+var dataFileMap = map[string]int{
+        "datafile-0-b":     0,
+        "datafile-1-b":     1,
+        "datafile-1-kB":    1 * humanize.KiByte,
+        "datafile-10-kB":   10 * humanize.KiByte,
+        "datafile-33-kB":   33 * humanize.KiByte,
+        "datafile-100-kB":  100 * humanize.KiByte,
+        "datafile-1.03-MB": 1056 * humanize.KiByte,
+        "datafile-1-MB":    1 * humanize.MiByte,
+        "datafile-5-MB":    5 * humanize.MiByte,
+        "datafile-6-MB":    6 * humanize.MiByte,
+        "datafile-11-MB":   11 * humanize.MiByte,
+        "datafile-65-MB":   65 * humanize.MiByte,
+        "datafile-129-MB":  129 * humanize.MiByte,
+}
+
+var dataFileCRC32 = map[string]uint32{}
+
+func isFullMode() bool {
+        return os.Getenv("MINT_MODE") == "full"
+}
+
+func getFuncName() string {
+        return getFuncNameLoc(2)
+}
+
+func getFuncNameLoc(caller int) string {
+        pc, _, _, _ := runtime.Caller(caller)
+        return strings.TrimPrefix(runtime.FuncForPC(pc).Name(), "main.")
+}
+
+// Tests bucket re-create errors.
+func testMakeBucketError() {
+        region := "eu-central-1"
+
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "MakeBucket(bucketName, region)"
+        // initialize logging params
+        args := map[string]interface{}{
+                "bucketName": "",
+                "region":     region,
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket in 'eu-central-1'.
+        if err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: region}); err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket Failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName, c)
+
+        if err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: region}); err == nil {
+                logError(testName, function, args, startTime, "", "Bucket already exists", err)
+                return
+        }
+        // Verify valid error response from server.
+        if minio.ToErrorResponse(err).Code != "BucketAlreadyExists" &&
+                minio.ToErrorResponse(err).Code != "BucketAlreadyOwnedByYou" {
+                logError(testName, function, args, startTime, "", "Invalid error returned by server", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testMetadataSizeLimit() {
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(bucketName, objectName, reader, objectSize, opts)"
+        args := map[string]interface{}{
+                "bucketName":        "",
+                "objectName":        "",
+                "opts.UserMetadata": "",
+        }
+        rand.Seed(startTime.Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client creation failed", err)
+                return
+        }
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        const HeaderSizeLimit = 8 * 1024
+        const UserMetadataLimit = 2 * 1024
+
+        // Meta-data greater than the 2 KB limit of AWS - PUT calls with this meta-data should fail
+        metadata := make(map[string]string)
+        metadata["X-Amz-Meta-Mint-Test"] = string(bytes.Repeat([]byte("m"), 1+UserMetadataLimit-len("X-Amz-Meta-Mint-Test")))
+        args["metadata"] = fmt.Sprint(metadata)
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(nil), 0, minio.PutObjectOptions{UserMetadata: metadata})
+        if err == nil {
+                logError(testName, function, args, startTime, "", "Created object with user-defined metadata exceeding metadata size limits", nil)
+                return
+        }
+
+        // Meta-data (headers) greater than the 8 KB limit of AWS - PUT calls with this meta-data should fail
+        metadata = make(map[string]string)
+        metadata["X-Amz-Mint-Test"] = string(bytes.Repeat([]byte("m"), 1+HeaderSizeLimit-len("X-Amz-Mint-Test")))
+        args["metadata"] = fmt.Sprint(metadata)
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(nil), 0, minio.PutObjectOptions{UserMetadata: metadata})
+        if err == nil {
+                logError(testName, function, args, startTime, "", "Created object with headers exceeding header size limits", nil)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests various bucket supported formats.
+func testMakeBucketRegions() {
+        region := "eu-central-1"
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "MakeBucket(bucketName, region)"
+        // initialize logging params
+        args := map[string]interface{}{
+                "bucketName": "",
+                "region":     region,
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket in 'eu-central-1'.
+        if err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: region}); err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        // Delete all objects and buckets
+        if err = cleanupBucket(bucketName, c); err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                return
+        }
+
+        // Make a new bucket with '.' in its name, in 'us-west-2'. This
+        // request is internally staged into a path style instead of
+        // virtual host style.
+        region = "us-west-2"
+        args["region"] = region
+        if err = c.MakeBucket(context.Background(), bucketName+".withperiod", minio.MakeBucketOptions{Region: region}); err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        // Delete all objects and buckets
+        if err = cleanupBucket(bucketName+".withperiod", c); err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                return
+        }
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test PutObject using a large data to trigger multipart readat
+func testPutObjectReadAt() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(bucketName, objectName, reader, opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "opts":       "objectContentType",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        bufSize := dataFileMap["datafile-129-MB"]
+        reader := getDataReader("datafile-129-MB")
+        defer reader.Close()
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        // Object content type
+        objectContentType := "binary/octet-stream"
+        args["objectContentType"] = objectContentType
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: objectContentType})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Get Object failed", err)
+                return
+        }
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat Object failed", err)
+                return
+        }
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", fmt.Sprintf("Number of bytes in stat does not match, expected %d got %d", bufSize, st.Size), err)
+                return
+        }
+        if st.ContentType != objectContentType && st.ContentType != "application/octet-stream" {
+                logError(testName, function, args, startTime, "", "Content types don't match", err)
+                return
+        }
+        if err := crcMatchesName(r, "datafile-129-MB"); err != nil {
+                logError(testName, function, args, startTime, "", "data CRC check failed", err)
+                return
+        }
+        if err := r.Close(); err != nil {
+                logError(testName, function, args, startTime, "", "Object Close failed", err)
+                return
+        }
+        if err := r.Close(); err == nil {
+                logError(testName, function, args, startTime, "", "Object is already closed, didn't return error on Close", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testListObjectVersions() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "ListObjectVersions(bucketName, prefix, recursive)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "prefix":     "",
+                "recursive":  "",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        err = c.EnableVersioning(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Enable versioning failed", err)
+                return
+        }
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        bufSize := dataFileMap["datafile-10-kB"]
+        reader := getDataReader("datafile-10-kB")
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+        reader.Close()
+
+        bufSize = dataFileMap["datafile-1-b"]
+        reader = getDataReader("datafile-1-b")
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+        reader.Close()
+
+        err = c.RemoveObject(context.Background(), bucketName, objectName, minio.RemoveObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Unexpected object deletion", err)
+                return
+        }
+
+        var deleteMarkers, versions int
+
+        objectsInfo := c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: true})
+        for info := range objectsInfo {
+                if info.Err != nil {
+                        logError(testName, function, args, startTime, "", "Unexpected error during listing objects", err)
+                        return
+                }
+                if info.Key != objectName {
+                        logError(testName, function, args, startTime, "", "Unexpected object name in listing objects", nil)
+                        return
+                }
+                if info.VersionID == "" {
+                        logError(testName, function, args, startTime, "", "Unexpected version id in listing objects", nil)
+                        return
+                }
+                if info.IsDeleteMarker {
+                        deleteMarkers++
+                        if !info.IsLatest {
+                                logError(testName, function, args, startTime, "", "Unexpected IsLatest field in listing objects", nil)
+                                return
+                        }
+                } else {
+                        versions++
+                }
+        }
+
+        if deleteMarkers != 1 {
+                logError(testName, function, args, startTime, "", "Unexpected number of DeleteMarker elements in listing objects", nil)
+                return
+        }
+
+        if versions != 2 {
+                logError(testName, function, args, startTime, "", "Unexpected number of Version elements in listing objects", nil)
+                return
+        }
+
+        // Delete all objects and their versions as long as the bucket itself
+        if err = cleanupVersionedBucket(bucketName, c); err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testStatObjectWithVersioning() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "StatObject"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        err = c.EnableVersioning(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Enable versioning failed", err)
+                return
+        }
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        bufSize := dataFileMap["datafile-10-kB"]
+        reader := getDataReader("datafile-10-kB")
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+        reader.Close()
+
+        bufSize = dataFileMap["datafile-1-b"]
+        reader = getDataReader("datafile-1-b")
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+        reader.Close()
+
+        objectsInfo := c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: true})
+
+        var results []minio.ObjectInfo
+        for info := range objectsInfo {
+                if info.Err != nil {
+                        logError(testName, function, args, startTime, "", "Unexpected error during listing objects", err)
+                        return
+                }
+                results = append(results, info)
+        }
+
+        if len(results) != 2 {
+                logError(testName, function, args, startTime, "", "Unexpected number of Version elements in listing objects", nil)
+                return
+        }
+
+        for i := 0; i < len(results); i++ {
+                opts := minio.StatObjectOptions{VersionID: results[i].VersionID}
+                statInfo, err := c.StatObject(context.Background(), bucketName, objectName, opts)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "error during HEAD object", err)
+                        return
+                }
+                if statInfo.VersionID == "" || statInfo.VersionID != results[i].VersionID {
+                        logError(testName, function, args, startTime, "", "error during HEAD object, unexpected version id", err)
+                        return
+                }
+                if statInfo.ETag != results[i].ETag {
+                        logError(testName, function, args, startTime, "", "error during HEAD object, unexpected ETag", err)
+                        return
+                }
+                if statInfo.LastModified.Unix() != results[i].LastModified.Unix() {
+                        logError(testName, function, args, startTime, "", "error during HEAD object, unexpected Last-Modified", err)
+                        return
+                }
+                if statInfo.Size != results[i].Size {
+                        logError(testName, function, args, startTime, "", "error during HEAD object, unexpected Content-Length", err)
+                        return
+                }
+        }
+
+        // Delete all objects and their versions as long as the bucket itself
+        if err = cleanupVersionedBucket(bucketName, c); err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testGetObjectWithVersioning() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject()"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        err = c.EnableVersioning(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Enable versioning failed", err)
+                return
+        }
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        // Save the contents of datafiles to check with GetObject() reader output later
+        var buffers [][]byte
+        testFiles := []string{"datafile-1-b", "datafile-10-kB"}
+
+        for _, testFile := range testFiles {
+                r := getDataReader(testFile)
+                buf, err := io.ReadAll(r)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "unexpected failure", err)
+                        return
+                }
+                r.Close()
+                _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutObject failed", err)
+                        return
+                }
+                buffers = append(buffers, buf)
+        }
+
+        objectsInfo := c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: true})
+
+        var results []minio.ObjectInfo
+        for info := range objectsInfo {
+                if info.Err != nil {
+                        logError(testName, function, args, startTime, "", "Unexpected error during listing objects", err)
+                        return
+                }
+                results = append(results, info)
+        }
+
+        if len(results) != 2 {
+                logError(testName, function, args, startTime, "", "Unexpected number of Version elements in listing objects", nil)
+                return
+        }
+
+        sort.SliceStable(results, func(i, j int) bool {
+                return results[i].Size < results[j].Size
+        })
+
+        sort.SliceStable(buffers, func(i, j int) bool {
+                return len(buffers[i]) < len(buffers[j])
+        })
+
+        for i := 0; i < len(results); i++ {
+                opts := minio.GetObjectOptions{VersionID: results[i].VersionID}
+                reader, err := c.GetObject(context.Background(), bucketName, objectName, opts)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "error during  GET object", err)
+                        return
+                }
+                statInfo, err := reader.Stat()
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "error during calling reader.Stat()", err)
+                        return
+                }
+                if statInfo.ETag != results[i].ETag {
+                        logError(testName, function, args, startTime, "", "error during HEAD object, unexpected ETag", err)
+                        return
+                }
+                if statInfo.LastModified.Unix() != results[i].LastModified.Unix() {
+                        logError(testName, function, args, startTime, "", "error during HEAD object, unexpected Last-Modified", err)
+                        return
+                }
+                if statInfo.Size != results[i].Size {
+                        logError(testName, function, args, startTime, "", "error during HEAD object, unexpected Content-Length", err)
+                        return
+                }
+
+                tmpBuffer := bytes.NewBuffer([]byte{})
+                _, err = io.Copy(tmpBuffer, reader)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "unexpected io.Copy()", err)
+                        return
+                }
+
+                if !bytes.Equal(tmpBuffer.Bytes(), buffers[i]) {
+                        logError(testName, function, args, startTime, "", "unexpected content of GetObject()", err)
+                        return
+                }
+        }
+
+        // Delete all objects and their versions as long as the bucket itself
+        if err = cleanupVersionedBucket(bucketName, c); err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testPutObjectWithVersioning() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject()"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        err = c.EnableVersioning(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Enable versioning failed", err)
+                return
+        }
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        const n = 10
+        // Read input...
+
+        // Save the data concurrently.
+        var wg sync.WaitGroup
+        wg.Add(n)
+        buffers := make([][]byte, n)
+        var errs [n]error
+        for i := 0; i < n; i++ {
+                r := newRandomReader(int64((1<<20)*i+i), int64(i))
+                buf, err := io.ReadAll(r)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "unexpected failure", err)
+                        return
+                }
+                buffers[i] = buf
+
+                go func(i int) {
+                        defer wg.Done()
+                        _, errs[i] = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{PartSize: 5 << 20})
+                }(i)
+        }
+        wg.Wait()
+        for _, err := range errs {
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutObject failed", err)
+                        return
+                }
+        }
+
+        objectsInfo := c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: true})
+        var results []minio.ObjectInfo
+        for info := range objectsInfo {
+                if info.Err != nil {
+                        logError(testName, function, args, startTime, "", "Unexpected error during listing objects", err)
+                        return
+                }
+                results = append(results, info)
+        }
+
+        if len(results) != n {
+                logError(testName, function, args, startTime, "", "Unexpected number of Version elements in listing objects", nil)
+                return
+        }
+
+        sort.Slice(results, func(i, j int) bool {
+                return results[i].Size < results[j].Size
+        })
+
+        sort.Slice(buffers, func(i, j int) bool {
+                return len(buffers[i]) < len(buffers[j])
+        })
+
+        for i := 0; i < len(results); i++ {
+                opts := minio.GetObjectOptions{VersionID: results[i].VersionID}
+                reader, err := c.GetObject(context.Background(), bucketName, objectName, opts)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "error during  GET object", err)
+                        return
+                }
+                statInfo, err := reader.Stat()
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "error during calling reader.Stat()", err)
+                        return
+                }
+                if statInfo.ETag != results[i].ETag {
+                        logError(testName, function, args, startTime, "", "error during HEAD object, unexpected ETag", err)
+                        return
+                }
+                if statInfo.LastModified.Unix() != results[i].LastModified.Unix() {
+                        logError(testName, function, args, startTime, "", "error during HEAD object, unexpected Last-Modified", err)
+                        return
+                }
+                if statInfo.Size != results[i].Size {
+                        logError(testName, function, args, startTime, "", "error during HEAD object, unexpected Content-Length", err)
+                        return
+                }
+
+                tmpBuffer := bytes.NewBuffer([]byte{})
+                _, err = io.Copy(tmpBuffer, reader)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "unexpected io.Copy()", err)
+                        return
+                }
+
+                if !bytes.Equal(tmpBuffer.Bytes(), buffers[i]) {
+                        logError(testName, function, args, startTime, "", "unexpected content of GetObject()", err)
+                        return
+                }
+        }
+
+        // Delete all objects and their versions as long as the bucket itself
+        if err = cleanupVersionedBucket(bucketName, c); err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testCopyObjectWithVersioning() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject()"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        err = c.EnableVersioning(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Enable versioning failed", err)
+                return
+        }
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        testFiles := []string{"datafile-1-b", "datafile-10-kB"}
+        for _, testFile := range testFiles {
+                r := getDataReader(testFile)
+                buf, err := io.ReadAll(r)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "unexpected failure", err)
+                        return
+                }
+                r.Close()
+                _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutObject failed", err)
+                        return
+                }
+        }
+
+        objectsInfo := c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: true})
+        var infos []minio.ObjectInfo
+        for info := range objectsInfo {
+                if info.Err != nil {
+                        logError(testName, function, args, startTime, "", "Unexpected error during listing objects", err)
+                        return
+                }
+                infos = append(infos, info)
+        }
+
+        sort.Slice(infos, func(i, j int) bool {
+                return infos[i].Size < infos[j].Size
+        })
+
+        reader, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{VersionID: infos[0].VersionID})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject of the oldest version content failed", err)
+                return
+        }
+
+        oldestContent, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Reading the oldest object version failed", err)
+                return
+        }
+
+        // Copy Source
+        srcOpts := minio.CopySrcOptions{
+                Bucket:    bucketName,
+                Object:    objectName,
+                VersionID: infos[0].VersionID,
+        }
+        args["src"] = srcOpts
+
+        dstOpts := minio.CopyDestOptions{
+                Bucket: bucketName,
+                Object: objectName + "-copy",
+        }
+        args["dst"] = dstOpts
+
+        // Perform the Copy
+        if _, err = c.CopyObject(context.Background(), dstOpts, srcOpts); err != nil {
+                logError(testName, function, args, startTime, "", "CopyObject failed", err)
+                return
+        }
+
+        // Destination object
+        readerCopy, err := c.GetObject(context.Background(), bucketName, objectName+"-copy", minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+        defer readerCopy.Close()
+
+        newestContent, err := io.ReadAll(readerCopy)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Reading from GetObject reader failed", err)
+                return
+        }
+
+        if len(newestContent) == 0 || !bytes.Equal(oldestContent, newestContent) {
+                logError(testName, function, args, startTime, "", "Unexpected destination object content", err)
+                return
+        }
+
+        // Delete all objects and their versions as long as the bucket itself
+        if err = cleanupVersionedBucket(bucketName, c); err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testConcurrentCopyObjectWithVersioning() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject()"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        err = c.EnableVersioning(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Enable versioning failed", err)
+                return
+        }
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        testFiles := []string{"datafile-10-kB"}
+        for _, testFile := range testFiles {
+                r := getDataReader(testFile)
+                buf, err := io.ReadAll(r)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "unexpected failure", err)
+                        return
+                }
+                r.Close()
+                _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutObject failed", err)
+                        return
+                }
+        }
+
+        objectsInfo := c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: true})
+        var infos []minio.ObjectInfo
+        for info := range objectsInfo {
+                if info.Err != nil {
+                        logError(testName, function, args, startTime, "", "Unexpected error during listing objects", err)
+                        return
+                }
+                infos = append(infos, info)
+        }
+
+        sort.Slice(infos, func(i, j int) bool {
+                return infos[i].Size < infos[j].Size
+        })
+
+        reader, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{VersionID: infos[0].VersionID})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject of the oldest version content failed", err)
+                return
+        }
+
+        oldestContent, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Reading the oldest object version failed", err)
+                return
+        }
+
+        // Copy Source
+        srcOpts := minio.CopySrcOptions{
+                Bucket:    bucketName,
+                Object:    objectName,
+                VersionID: infos[0].VersionID,
+        }
+        args["src"] = srcOpts
+
+        dstOpts := minio.CopyDestOptions{
+                Bucket: bucketName,
+                Object: objectName + "-copy",
+        }
+        args["dst"] = dstOpts
+
+        // Perform the Copy concurrently
+        const n = 10
+        var wg sync.WaitGroup
+        wg.Add(n)
+        var errs [n]error
+        for i := 0; i < n; i++ {
+                go func(i int) {
+                        defer wg.Done()
+                        _, errs[i] = c.CopyObject(context.Background(), dstOpts, srcOpts)
+                }(i)
+        }
+        wg.Wait()
+        for _, err := range errs {
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "CopyObject failed", err)
+                        return
+                }
+        }
+
+        objectsInfo = c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: false, Prefix: dstOpts.Object})
+        infos = []minio.ObjectInfo{}
+        for info := range objectsInfo {
+                // Destination object
+                readerCopy, err := c.GetObject(context.Background(), bucketName, objectName+"-copy", minio.GetObjectOptions{VersionID: info.VersionID})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "GetObject failed", err)
+                        return
+                }
+                defer readerCopy.Close()
+
+                newestContent, err := io.ReadAll(readerCopy)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "Reading from GetObject reader failed", err)
+                        return
+                }
+
+                if len(newestContent) == 0 || !bytes.Equal(oldestContent, newestContent) {
+                        logError(testName, function, args, startTime, "", "Unexpected destination object content", err)
+                        return
+                }
+                infos = append(infos, info)
+        }
+
+        if len(infos) != n {
+                logError(testName, function, args, startTime, "", "Unexpected number of Version elements in listing objects", nil)
+                return
+        }
+
+        // Delete all objects and their versions as long as the bucket itself
+        if err = cleanupVersionedBucket(bucketName, c); err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testComposeObjectWithVersioning() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "ComposeObject()"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        err = c.EnableVersioning(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Enable versioning failed", err)
+                return
+        }
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        // var testFiles = []string{"datafile-5-MB", "datafile-10-kB"}
+        testFiles := []string{"datafile-5-MB", "datafile-10-kB"}
+        var testFilesBytes [][]byte
+
+        for _, testFile := range testFiles {
+                r := getDataReader(testFile)
+                buf, err := io.ReadAll(r)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "unexpected failure", err)
+                        return
+                }
+                r.Close()
+                _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutObject failed", err)
+                        return
+                }
+                testFilesBytes = append(testFilesBytes, buf)
+        }
+
+        objectsInfo := c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: true})
+
+        var results []minio.ObjectInfo
+        for info := range objectsInfo {
+                if info.Err != nil {
+                        logError(testName, function, args, startTime, "", "Unexpected error during listing objects", err)
+                        return
+                }
+                results = append(results, info)
+        }
+
+        sort.SliceStable(results, func(i, j int) bool {
+                return results[i].Size > results[j].Size
+        })
+
+        // Source objects to concatenate. We also specify decryption
+        // key for each
+        src1 := minio.CopySrcOptions{
+                Bucket:    bucketName,
+                Object:    objectName,
+                VersionID: results[0].VersionID,
+        }
+
+        src2 := minio.CopySrcOptions{
+                Bucket:    bucketName,
+                Object:    objectName,
+                VersionID: results[1].VersionID,
+        }
+
+        dst := minio.CopyDestOptions{
+                Bucket: bucketName,
+                Object: objectName + "-copy",
+        }
+
+        _, err = c.ComposeObject(context.Background(), dst, src1, src2)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ComposeObject failed", err)
+                return
+        }
+
+        // Destination object
+        readerCopy, err := c.GetObject(context.Background(), bucketName, objectName+"-copy", minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject of the copy object failed", err)
+                return
+        }
+        defer readerCopy.Close()
+
+        copyContentBytes, err := io.ReadAll(readerCopy)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Reading from the copy object reader failed", err)
+                return
+        }
+
+        var expectedContent []byte
+        for _, fileBytes := range testFilesBytes {
+                expectedContent = append(expectedContent, fileBytes...)
+        }
+
+        if len(copyContentBytes) == 0 || !bytes.Equal(copyContentBytes, expectedContent) {
+                logError(testName, function, args, startTime, "", "Unexpected destination object content", err)
+                return
+        }
+
+        // Delete all objects and their versions as long as the bucket itself
+        if err = cleanupVersionedBucket(bucketName, c); err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testRemoveObjectWithVersioning() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "DeleteObject()"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        err = c.EnableVersioning(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Enable versioning failed", err)
+                return
+        }
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, getDataReader("datafile-10-kB"), int64(dataFileMap["datafile-10-kB"]), minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        objectsInfo := c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: true})
+        var version minio.ObjectInfo
+        for info := range objectsInfo {
+                if info.Err != nil {
+                        logError(testName, function, args, startTime, "", "Unexpected error during listing objects", err)
+                        return
+                }
+                version = info
+                break
+        }
+
+        err = c.RemoveObject(context.Background(), bucketName, objectName, minio.RemoveObjectOptions{VersionID: version.VersionID})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "DeleteObject failed", err)
+                return
+        }
+
+        objectsInfo = c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: true})
+        for range objectsInfo {
+                logError(testName, function, args, startTime, "", "Unexpected versioning info, should not have any one ", err)
+                return
+        }
+        // test delete marker version id is non-null
+        _, err = c.PutObject(context.Background(), bucketName, objectName, getDataReader("datafile-10-kB"), int64(dataFileMap["datafile-10-kB"]), minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+        // create delete marker
+        err = c.RemoveObject(context.Background(), bucketName, objectName, minio.RemoveObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "DeleteObject failed", err)
+                return
+        }
+        objectsInfo = c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: true})
+        idx := 0
+        for info := range objectsInfo {
+                if info.Err != nil {
+                        logError(testName, function, args, startTime, "", "Unexpected error during listing objects", err)
+                        return
+                }
+                if idx == 0 {
+                        if !info.IsDeleteMarker {
+                                logError(testName, function, args, startTime, "", "Unexpected error - expected delete marker to have been created", err)
+                                return
+                        }
+                        if info.VersionID == "" {
+                                logError(testName, function, args, startTime, "", "Unexpected error - expected delete marker to be versioned", err)
+                                return
+                        }
+                }
+                idx++
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testRemoveObjectsWithVersioning() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "DeleteObjects()"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        err = c.EnableVersioning(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Enable versioning failed", err)
+                return
+        }
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, getDataReader("datafile-10-kB"), int64(dataFileMap["datafile-10-kB"]), minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        objectsVersions := make(chan minio.ObjectInfo)
+        go func() {
+                objectsVersionsInfo := c.ListObjects(context.Background(), bucketName,
+                        minio.ListObjectsOptions{WithVersions: true, Recursive: true})
+                for info := range objectsVersionsInfo {
+                        if info.Err != nil {
+                                logError(testName, function, args, startTime, "", "Unexpected error during listing objects", err)
+                                return
+                        }
+                        objectsVersions <- info
+                }
+                close(objectsVersions)
+        }()
+
+        removeErrors := c.RemoveObjects(context.Background(), bucketName, objectsVersions, minio.RemoveObjectsOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "DeleteObjects call failed", err)
+                return
+        }
+
+        for e := range removeErrors {
+                if e.Err != nil {
+                        logError(testName, function, args, startTime, "", "Single delete operation failed", err)
+                        return
+                }
+        }
+
+        objectsVersionsInfo := c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: true})
+        for range objectsVersionsInfo {
+                logError(testName, function, args, startTime, "", "Unexpected versioning info, should not have any one ", err)
+                return
+        }
+
+        err = c.RemoveBucket(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testObjectTaggingWithVersioning() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "{Get,Set,Remove}ObjectTagging()"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        err = c.EnableVersioning(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Enable versioning failed", err)
+                return
+        }
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        for _, file := range []string{"datafile-1-b", "datafile-10-kB"} {
+                _, err = c.PutObject(context.Background(), bucketName, objectName, getDataReader(file), int64(dataFileMap[file]), minio.PutObjectOptions{})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutObject failed", err)
+                        return
+                }
+        }
+
+        versionsInfo := c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{WithVersions: true, Recursive: true})
+
+        var versions []minio.ObjectInfo
+        for info := range versionsInfo {
+                if info.Err != nil {
+                        logError(testName, function, args, startTime, "", "Unexpected error during listing objects", err)
+                        return
+                }
+                versions = append(versions, info)
+        }
+
+        sort.SliceStable(versions, func(i, j int) bool {
+                return versions[i].Size < versions[j].Size
+        })
+
+        tagsV1 := map[string]string{"key1": "val1"}
+        t1, err := tags.MapToObjectTags(tagsV1)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObjectTagging (1) failed", err)
+                return
+        }
+
+        err = c.PutObjectTagging(context.Background(), bucketName, objectName, t1, minio.PutObjectTaggingOptions{VersionID: versions[0].VersionID})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObjectTagging (1) failed", err)
+                return
+        }
+
+        tagsV2 := map[string]string{"key2": "val2"}
+        t2, err := tags.MapToObjectTags(tagsV2)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObjectTagging (1) failed", err)
+                return
+        }
+
+        err = c.PutObjectTagging(context.Background(), bucketName, objectName, t2, minio.PutObjectTaggingOptions{VersionID: versions[1].VersionID})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObjectTagging (2) failed", err)
+                return
+        }
+
+        tagsEqual := func(tags1, tags2 map[string]string) bool {
+                for k1, v1 := range tags1 {
+                        v2, found := tags2[k1]
+                        if found {
+                                if v1 != v2 {
+                                        return false
+                                }
+                        }
+                }
+                return true
+        }
+
+        gotTagsV1, err := c.GetObjectTagging(context.Background(), bucketName, objectName, minio.GetObjectTaggingOptions{VersionID: versions[0].VersionID})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObjectTagging failed", err)
+                return
+        }
+
+        if !tagsEqual(t1.ToMap(), gotTagsV1.ToMap()) {
+                logError(testName, function, args, startTime, "", "Unexpected tags content (1)", err)
+                return
+        }
+
+        gotTagsV2, err := c.GetObjectTagging(context.Background(), bucketName, objectName, minio.GetObjectTaggingOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObjectTaggingContext failed", err)
+                return
+        }
+
+        if !tagsEqual(t2.ToMap(), gotTagsV2.ToMap()) {
+                logError(testName, function, args, startTime, "", "Unexpected tags content (2)", err)
+                return
+        }
+
+        err = c.RemoveObjectTagging(context.Background(), bucketName, objectName, minio.RemoveObjectTaggingOptions{VersionID: versions[0].VersionID})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObjectTagging (2) failed", err)
+                return
+        }
+
+        emptyTags, err := c.GetObjectTagging(context.Background(), bucketName, objectName,
+                minio.GetObjectTaggingOptions{VersionID: versions[0].VersionID})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObjectTagging failed", err)
+                return
+        }
+
+        if len(emptyTags.ToMap()) != 0 {
+                logError(testName, function, args, startTime, "", "Unexpected tags content (2)", err)
+                return
+        }
+
+        // Delete all objects and their versions as long as the bucket itself
+        if err = cleanupVersionedBucket(bucketName, c); err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test PutObject with custom checksums.
+func testPutObjectWithChecksums() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(bucketName, objectName, reader,size, opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "opts":       "minio.PutObjectOptions{UserMetadata: metadata, Progress: progress}",
+        }
+
+        if !isFullMode() {
+                ignoredLog(testName, function, args, startTime, "Skipping functional tests for short/quick runs").Info()
+                return
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+        tests := []struct {
+                header string
+                hasher hash.Hash
+
+                // Checksum values
+                ChecksumCRC32  string
+                ChecksumCRC32C string
+                ChecksumSHA1   string
+                ChecksumSHA256 string
+        }{
+                {header: "x-amz-checksum-crc32", hasher: crc32.NewIEEE()},
+                {header: "x-amz-checksum-crc32c", hasher: crc32.New(crc32.MakeTable(crc32.Castagnoli))},
+                {header: "x-amz-checksum-sha1", hasher: sha1.New()},
+                {header: "x-amz-checksum-sha256", hasher: sha256.New()},
+        }
+
+        for i, test := range tests {
+                bufSize := dataFileMap["datafile-10-kB"]
+
+                // Save the data
+                objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+                args["objectName"] = objectName
+
+                cmpChecksum := func(got, want string) {
+                        if want != got {
+                                logError(testName, function, args, startTime, "", "checksum mismatch", fmt.Errorf("want %s, got %s", want, got))
+                                return
+                        }
+                }
+
+                meta := map[string]string{}
+                reader := getDataReader("datafile-10-kB")
+                b, err := io.ReadAll(reader)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "Read failed", err)
+                        return
+                }
+                h := test.hasher
+                h.Reset()
+                // Wrong CRC.
+                meta[test.header] = base64.StdEncoding.EncodeToString(h.Sum(nil))
+                args["metadata"] = meta
+                args["range"] = "false"
+
+                resp, err := c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(b), int64(bufSize), minio.PutObjectOptions{
+                        DisableMultipart: true,
+                        UserMetadata:     meta,
+                })
+                if err == nil {
+                        if i == 0 && resp.ChecksumCRC32 == "" {
+                                ignoredLog(testName, function, args, startTime, "Checksums does not appear to be supported by backend").Info()
+                                return
+                        }
+                        logError(testName, function, args, startTime, "", "PutObject failed", err)
+                        return
+                }
+
+                // Set correct CRC.
+                h.Write(b)
+                meta[test.header] = base64.StdEncoding.EncodeToString(h.Sum(nil))
+                reader.Close()
+
+                resp, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(b), int64(bufSize), minio.PutObjectOptions{
+                        DisableMultipart:     true,
+                        DisableContentSha256: true,
+                        UserMetadata:         meta,
+                })
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutObject failed", err)
+                        return
+                }
+                cmpChecksum(resp.ChecksumSHA256, meta["x-amz-checksum-sha256"])
+                cmpChecksum(resp.ChecksumSHA1, meta["x-amz-checksum-sha1"])
+                cmpChecksum(resp.ChecksumCRC32, meta["x-amz-checksum-crc32"])
+                cmpChecksum(resp.ChecksumCRC32C, meta["x-amz-checksum-crc32c"])
+
+                // Read the data back
+                gopts := minio.GetObjectOptions{Checksum: true}
+
+                r, err := c.GetObject(context.Background(), bucketName, objectName, gopts)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "GetObject failed", err)
+                        return
+                }
+
+                st, err := r.Stat()
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "Stat failed", err)
+                        return
+                }
+                cmpChecksum(st.ChecksumSHA256, meta["x-amz-checksum-sha256"])
+                cmpChecksum(st.ChecksumSHA1, meta["x-amz-checksum-sha1"])
+                cmpChecksum(st.ChecksumCRC32, meta["x-amz-checksum-crc32"])
+                cmpChecksum(st.ChecksumCRC32C, meta["x-amz-checksum-crc32c"])
+
+                if st.Size != int64(bufSize) {
+                        logError(testName, function, args, startTime, "", "Number of bytes returned by PutObject does not match GetObject, expected "+string(bufSize)+" got "+string(st.Size), err)
+                        return
+                }
+
+                if err := r.Close(); err != nil {
+                        logError(testName, function, args, startTime, "", "Object Close failed", err)
+                        return
+                }
+                if err := r.Close(); err == nil {
+                        logError(testName, function, args, startTime, "", "Object already closed, should respond with error", err)
+                        return
+                }
+
+                args["range"] = "true"
+                err = gopts.SetRange(100, 1000)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "SetRange failed", err)
+                        return
+                }
+                r, err = c.GetObject(context.Background(), bucketName, objectName, gopts)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "GetObject failed", err)
+                        return
+                }
+
+                b, err = io.ReadAll(r)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "Read failed", err)
+                        return
+                }
+                st, err = r.Stat()
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "Stat failed", err)
+                        return
+                }
+
+                // Range requests should return empty checksums...
+                cmpChecksum(st.ChecksumSHA256, "")
+                cmpChecksum(st.ChecksumSHA1, "")
+                cmpChecksum(st.ChecksumCRC32, "")
+                cmpChecksum(st.ChecksumCRC32C, "")
+
+                delete(args, "range")
+                delete(args, "metadata")
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test PutObject with custom checksums.
+func testPutMultipartObjectWithChecksums() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(bucketName, objectName, reader,size, opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "opts":       "minio.PutObjectOptions{UserMetadata: metadata, Progress: progress}",
+        }
+
+        if !isFullMode() {
+                ignoredLog(testName, function, args, startTime, "Skipping functional tests for short/quick runs").Info()
+                return
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        hashMultiPart := func(b []byte, partSize int, hasher hash.Hash) string {
+                r := bytes.NewReader(b)
+                tmp := make([]byte, partSize)
+                parts := 0
+                var all []byte
+                for {
+                        n, err := io.ReadFull(r, tmp)
+                        if err != nil && err != io.ErrUnexpectedEOF {
+                                logError(testName, function, args, startTime, "", "Calc crc failed", err)
+                        }
+                        if n == 0 {
+                                break
+                        }
+                        parts++
+                        hasher.Reset()
+                        hasher.Write(tmp[:n])
+                        all = append(all, hasher.Sum(nil)...)
+                        if err != nil {
+                                break
+                        }
+                }
+                hasher.Reset()
+                hasher.Write(all)
+                return fmt.Sprintf("%s-%d", base64.StdEncoding.EncodeToString(hasher.Sum(nil)), parts)
+        }
+        defer cleanupBucket(bucketName, c)
+        tests := []struct {
+                header string
+                hasher hash.Hash
+
+                // Checksum values
+                ChecksumCRC32  string
+                ChecksumCRC32C string
+                ChecksumSHA1   string
+                ChecksumSHA256 string
+        }{
+                // Currently there is no way to override the checksum type.
+                {header: "x-amz-checksum-crc32c", hasher: crc32.New(crc32.MakeTable(crc32.Castagnoli)), ChecksumCRC32C: "OpEx0Q==-13"},
+        }
+
+        for _, test := range tests {
+                bufSize := dataFileMap["datafile-129-MB"]
+
+                // Save the data
+                objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+                args["objectName"] = objectName
+
+                cmpChecksum := func(got, want string) {
+                        if want != got {
+                                // logError(testName, function, args, startTime, "", "checksum mismatch", fmt.Errorf("want %s, got %s", want, got))
+                                fmt.Printf("want %s, got %s\n", want, got)
+                                return
+                        }
+                }
+
+                const partSize = 10 << 20
+                reader := getDataReader("datafile-129-MB")
+                b, err := io.ReadAll(reader)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "Read failed", err)
+                        return
+                }
+                reader.Close()
+                h := test.hasher
+                h.Reset()
+                test.ChecksumCRC32C = hashMultiPart(b, partSize, test.hasher)
+
+                // Set correct CRC.
+
+                resp, err := c.PutObject(context.Background(), bucketName, objectName, io.NopCloser(bytes.NewReader(b)), int64(bufSize), minio.PutObjectOptions{
+                        DisableContentSha256: true,
+                        DisableMultipart:     false,
+                        UserMetadata:         nil,
+                        PartSize:             partSize,
+                })
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutObject failed", err)
+                        return
+                }
+                cmpChecksum(resp.ChecksumSHA256, test.ChecksumSHA256)
+                cmpChecksum(resp.ChecksumSHA1, test.ChecksumSHA1)
+                cmpChecksum(resp.ChecksumCRC32, test.ChecksumCRC32)
+                cmpChecksum(resp.ChecksumCRC32C, test.ChecksumCRC32C)
+
+                // Read the data back
+                gopts := minio.GetObjectOptions{Checksum: true}
+                gopts.PartNumber = 2
+
+                // We cannot use StatObject, since it ignores partnumber.
+                r, err := c.GetObject(context.Background(), bucketName, objectName, gopts)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "GetObject failed", err)
+                        return
+                }
+                io.Copy(io.Discard, r)
+                st, err := r.Stat()
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "Stat failed", err)
+                        return
+                }
+
+                // Test part 2 checksum...
+                h.Reset()
+                h.Write(b[partSize : 2*partSize])
+                got := base64.StdEncoding.EncodeToString(h.Sum(nil))
+                if test.ChecksumSHA256 != "" {
+                        cmpChecksum(st.ChecksumSHA256, got)
+                }
+                if test.ChecksumSHA1 != "" {
+                        cmpChecksum(st.ChecksumSHA1, got)
+                }
+                if test.ChecksumCRC32 != "" {
+                        cmpChecksum(st.ChecksumCRC32, got)
+                }
+                if test.ChecksumCRC32C != "" {
+                        cmpChecksum(st.ChecksumCRC32C, got)
+                }
+
+                delete(args, "metadata")
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test PutObject with trailing checksums.
+func testTrailingChecksums() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(bucketName, objectName, reader,size, opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "opts":       "minio.PutObjectOptions{UserMetadata: metadata, Progress: progress}",
+        }
+
+        if !isFullMode() {
+                ignoredLog(testName, function, args, startTime, "Skipping functional tests for short/quick runs").Info()
+                return
+        }
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:           credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure:          mustParseBool(os.Getenv(enableHTTPS)),
+                        TrailingHeaders: true,
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        hashMultiPart := func(b []byte, partSize int, hasher hash.Hash) string {
+                r := bytes.NewReader(b)
+                tmp := make([]byte, partSize)
+                parts := 0
+                var all []byte
+                for {
+                        n, err := io.ReadFull(r, tmp)
+                        if err != nil && err != io.ErrUnexpectedEOF {
+                                logError(testName, function, args, startTime, "", "Calc crc failed", err)
+                        }
+                        if n == 0 {
+                                break
+                        }
+                        parts++
+                        hasher.Reset()
+                        hasher.Write(tmp[:n])
+                        all = append(all, hasher.Sum(nil)...)
+                        if err != nil {
+                                break
+                        }
+                }
+                hasher.Reset()
+                hasher.Write(all)
+                return fmt.Sprintf("%s-%d", base64.StdEncoding.EncodeToString(hasher.Sum(nil)), parts)
+        }
+        defer cleanupBucket(bucketName, c)
+        tests := []struct {
+                header string
+                hasher hash.Hash
+
+                // Checksum values
+                ChecksumCRC32  string
+                ChecksumCRC32C string
+                ChecksumSHA1   string
+                ChecksumSHA256 string
+                PO             minio.PutObjectOptions
+        }{
+                // Currently there is no way to override the checksum type.
+                {
+                        header:         "x-amz-checksum-crc32c",
+                        hasher:         crc32.New(crc32.MakeTable(crc32.Castagnoli)),
+                        ChecksumCRC32C: "set",
+                        PO: minio.PutObjectOptions{
+                                DisableContentSha256: true,
+                                DisableMultipart:     false,
+                                UserMetadata:         nil,
+                                PartSize:             5 << 20,
+                        },
+                },
+                {
+                        header:         "x-amz-checksum-crc32c",
+                        hasher:         crc32.New(crc32.MakeTable(crc32.Castagnoli)),
+                        ChecksumCRC32C: "set",
+                        PO: minio.PutObjectOptions{
+                                DisableContentSha256: true,
+                                DisableMultipart:     false,
+                                UserMetadata:         nil,
+                                PartSize:             6_645_654, // Rather arbitrary size
+                        },
+                },
+                {
+                        header:         "x-amz-checksum-crc32c",
+                        hasher:         crc32.New(crc32.MakeTable(crc32.Castagnoli)),
+                        ChecksumCRC32C: "set",
+                        PO: minio.PutObjectOptions{
+                                DisableContentSha256: false,
+                                DisableMultipart:     false,
+                                UserMetadata:         nil,
+                                PartSize:             5 << 20,
+                        },
+                },
+                {
+                        header:         "x-amz-checksum-crc32c",
+                        hasher:         crc32.New(crc32.MakeTable(crc32.Castagnoli)),
+                        ChecksumCRC32C: "set",
+                        PO: minio.PutObjectOptions{
+                                DisableContentSha256: false,
+                                DisableMultipart:     false,
+                                UserMetadata:         nil,
+                                PartSize:             6_645_654, // Rather arbitrary size
+                        },
+                },
+        }
+
+        for _, test := range tests {
+                bufSize := dataFileMap["datafile-11-MB"]
+
+                // Save the data
+                objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+                args["objectName"] = objectName
+
+                cmpChecksum := func(got, want string) {
+                        if want != got {
+                                logError(testName, function, args, startTime, "", "checksum mismatch", fmt.Errorf("want %q, got %q", want, got))
+                                return
+                        }
+                }
+
+                reader := getDataReader("datafile-11-MB")
+                b, err := io.ReadAll(reader)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "Read failed", err)
+                        return
+                }
+                reader.Close()
+                h := test.hasher
+                h.Reset()
+                test.ChecksumCRC32C = hashMultiPart(b, int(test.PO.PartSize), test.hasher)
+
+                // Set correct CRC.
+                // c.TraceOn(os.Stderr)
+                resp, err := c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(b), int64(bufSize), test.PO)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutObject failed", err)
+                        return
+                }
+                // c.TraceOff()
+                cmpChecksum(resp.ChecksumSHA256, test.ChecksumSHA256)
+                cmpChecksum(resp.ChecksumSHA1, test.ChecksumSHA1)
+                cmpChecksum(resp.ChecksumCRC32, test.ChecksumCRC32)
+                cmpChecksum(resp.ChecksumCRC32C, test.ChecksumCRC32C)
+
+                // Read the data back
+                gopts := minio.GetObjectOptions{Checksum: true}
+                gopts.PartNumber = 2
+
+                // We cannot use StatObject, since it ignores partnumber.
+                r, err := c.GetObject(context.Background(), bucketName, objectName, gopts)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "GetObject failed", err)
+                        return
+                }
+                io.Copy(io.Discard, r)
+                st, err := r.Stat()
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "Stat failed", err)
+                        return
+                }
+
+                // Test part 2 checksum...
+                h.Reset()
+                p2 := b[test.PO.PartSize:]
+                if len(p2) > int(test.PO.PartSize) {
+                        p2 = p2[:test.PO.PartSize]
+                }
+                h.Write(p2)
+                got := base64.StdEncoding.EncodeToString(h.Sum(nil))
+                if test.ChecksumSHA256 != "" {
+                        cmpChecksum(st.ChecksumSHA256, got)
+                }
+                if test.ChecksumSHA1 != "" {
+                        cmpChecksum(st.ChecksumSHA1, got)
+                }
+                if test.ChecksumCRC32 != "" {
+                        cmpChecksum(st.ChecksumCRC32, got)
+                }
+                if test.ChecksumCRC32C != "" {
+                        cmpChecksum(st.ChecksumCRC32C, got)
+                }
+
+                delete(args, "metadata")
+        }
+}
+
+// Test PutObject with custom checksums.
+func testPutObjectWithAutomaticChecksums() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(bucketName, objectName, reader,size, opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "opts":       "minio.PutObjectOptions{UserMetadata: metadata, Progress: progress}",
+        }
+
+        if !isFullMode() {
+                ignoredLog(testName, function, args, startTime, "Skipping functional tests for short/quick runs").Info()
+                return
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:           credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure:          mustParseBool(os.Getenv(enableHTTPS)),
+                        TrailingHeaders: true,
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+        tests := []struct {
+                header string
+                hasher hash.Hash
+
+                // Checksum values
+                ChecksumCRC32  string
+                ChecksumCRC32C string
+                ChecksumSHA1   string
+                ChecksumSHA256 string
+        }{
+                // Built-in will only add crc32c, when no MD5 nor SHA256.
+                {header: "x-amz-checksum-crc32c", hasher: crc32.New(crc32.MakeTable(crc32.Castagnoli))},
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+        // defer c.TraceOff()
+
+        for i, test := range tests {
+                bufSize := dataFileMap["datafile-10-kB"]
+
+                // Save the data
+                objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+                args["objectName"] = objectName
+
+                cmpChecksum := func(got, want string) {
+                        if want != got {
+                                logError(testName, function, args, startTime, "", "checksum mismatch", fmt.Errorf("want %s, got %s", want, got))
+                                return
+                        }
+                }
+
+                meta := map[string]string{}
+                reader := getDataReader("datafile-10-kB")
+                b, err := io.ReadAll(reader)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "Read failed", err)
+                        return
+                }
+
+                h := test.hasher
+                h.Reset()
+                h.Write(b)
+                meta[test.header] = base64.StdEncoding.EncodeToString(h.Sum(nil))
+                args["metadata"] = meta
+
+                resp, err := c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(b), int64(bufSize), minio.PutObjectOptions{
+                        DisableMultipart:     true,
+                        UserMetadata:         nil,
+                        DisableContentSha256: true,
+                        SendContentMd5:       false,
+                })
+                if err == nil {
+                        if i == 0 && resp.ChecksumCRC32C == "" {
+                                ignoredLog(testName, function, args, startTime, "Checksums does not appear to be supported by backend").Info()
+                                return
+                        }
+                } else {
+                        logError(testName, function, args, startTime, "", "PutObject failed", err)
+                        return
+                }
+                cmpChecksum(resp.ChecksumSHA256, meta["x-amz-checksum-sha256"])
+                cmpChecksum(resp.ChecksumSHA1, meta["x-amz-checksum-sha1"])
+                cmpChecksum(resp.ChecksumCRC32, meta["x-amz-checksum-crc32"])
+                cmpChecksum(resp.ChecksumCRC32C, meta["x-amz-checksum-crc32c"])
+
+                // Usually this will be the same as above, since we skip automatic checksum when SHA256 content is sent.
+                // When/if we add a checksum control to PutObjectOptions this will make more sense.
+                resp, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(b), int64(bufSize), minio.PutObjectOptions{
+                        DisableMultipart:     true,
+                        UserMetadata:         nil,
+                        DisableContentSha256: false,
+                        SendContentMd5:       false,
+                })
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutObject failed", err)
+                        return
+                }
+                // The checksum will not be enabled on HTTP, since it uses SHA256 blocks.
+                if mustParseBool(os.Getenv(enableHTTPS)) {
+                        cmpChecksum(resp.ChecksumSHA256, meta["x-amz-checksum-sha256"])
+                        cmpChecksum(resp.ChecksumSHA1, meta["x-amz-checksum-sha1"])
+                        cmpChecksum(resp.ChecksumCRC32, meta["x-amz-checksum-crc32"])
+                        cmpChecksum(resp.ChecksumCRC32C, meta["x-amz-checksum-crc32c"])
+                }
+
+                // Set SHA256 header manually
+                sh256 := sha256.Sum256(b)
+                meta = map[string]string{"x-amz-checksum-sha256": base64.StdEncoding.EncodeToString(sh256[:])}
+                args["metadata"] = meta
+                resp, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(b), int64(bufSize), minio.PutObjectOptions{
+                        DisableMultipart:     true,
+                        UserMetadata:         meta,
+                        DisableContentSha256: true,
+                        SendContentMd5:       false,
+                })
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutObject failed", err)
+                        return
+                }
+                cmpChecksum(resp.ChecksumSHA256, meta["x-amz-checksum-sha256"])
+                cmpChecksum(resp.ChecksumSHA1, meta["x-amz-checksum-sha1"])
+                cmpChecksum(resp.ChecksumCRC32, meta["x-amz-checksum-crc32"])
+                cmpChecksum(resp.ChecksumCRC32C, meta["x-amz-checksum-crc32c"])
+                delete(args, "metadata")
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test PutObject using a large data to trigger multipart readat
+func testPutObjectWithMetadata() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(bucketName, objectName, reader,size, opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "opts":       "minio.PutObjectOptions{UserMetadata: metadata, Progress: progress}",
+        }
+
+        if !isFullMode() {
+                ignoredLog(testName, function, args, startTime, "Skipping functional tests for short/quick runs").Info()
+                return
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Make bucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        bufSize := dataFileMap["datafile-129-MB"]
+        reader := getDataReader("datafile-129-MB")
+        defer reader.Close()
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        // Object custom metadata
+        customContentType := "custom/contenttype"
+
+        args["metadata"] = map[string][]string{
+                "Content-Type":         {customContentType},
+                "X-Amz-Meta-CustomKey": {"extra  spaces  in   value"},
+        }
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{
+                ContentType: customContentType,
+        })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes returned by PutObject does not match GetObject, expected "+string(bufSize)+" got "+string(st.Size), err)
+                return
+        }
+        if st.ContentType != customContentType && st.ContentType != "application/octet-stream" {
+                logError(testName, function, args, startTime, "", "ContentType does not match, expected "+customContentType+" got "+st.ContentType, err)
+                return
+        }
+        if err := crcMatchesName(r, "datafile-129-MB"); err != nil {
+                logError(testName, function, args, startTime, "", "data CRC check failed", err)
+                return
+        }
+        if err := r.Close(); err != nil {
+                logError(testName, function, args, startTime, "", "Object Close failed", err)
+                return
+        }
+        if err := r.Close(); err == nil {
+                logError(testName, function, args, startTime, "", "Object already closed, should respond with error", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testPutObjectWithContentLanguage() {
+        // initialize logging params
+        objectName := "test-object"
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(bucketName, objectName, reader, size, opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": objectName,
+                "size":       -1,
+                "opts":       "",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        data := []byte{}
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(data), int64(0), minio.PutObjectOptions{
+                ContentLanguage: "en",
+        })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        objInfo, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+
+        if objInfo.Metadata.Get("Content-Language") != "en" {
+                logError(testName, function, args, startTime, "", "Expected content-language 'en' doesn't match with StatObject return value", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test put object with streaming signature.
+func testPutObjectStreaming() {
+        // initialize logging params
+        objectName := "test-object"
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(bucketName, objectName, reader,size,opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": objectName,
+                "size":       -1,
+                "opts":       "",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Upload an object.
+        sizes := []int64{0, 64*1024 - 1, 64 * 1024}
+
+        for _, size := range sizes {
+                data := newRandomReader(size, size)
+                ui, err := c.PutObject(context.Background(), bucketName, objectName, data, int64(size), minio.PutObjectOptions{})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutObjectStreaming failed", err)
+                        return
+                }
+
+                if ui.Size != size {
+                        logError(testName, function, args, startTime, "", "PutObjectStreaming result has unexpected size", nil)
+                        return
+                }
+
+                objInfo, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "StatObject failed", err)
+                        return
+                }
+                if objInfo.Size != size {
+                        logError(testName, function, args, startTime, "", "Unexpected size", err)
+                        return
+                }
+
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test get object seeker from the end, using whence set to '2'.
+func testGetObjectSeekEnd() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(bucketName, objectName)"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Generate 33K of data.
+        bufSize := dataFileMap["datafile-33-kB"]
+        reader := getDataReader("datafile-33-kB")
+        defer reader.Close()
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        buf, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes read does not match, expected "+string(int64(bufSize))+" got "+string(st.Size), err)
+                return
+        }
+
+        pos, err := r.Seek(-100, 2)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Object Seek failed", err)
+                return
+        }
+        if pos != st.Size-100 {
+                logError(testName, function, args, startTime, "", "Incorrect position", err)
+                return
+        }
+        buf2 := make([]byte, 100)
+        m, err := readFull(r, buf2)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Error reading through readFull", err)
+                return
+        }
+        if m != len(buf2) {
+                logError(testName, function, args, startTime, "", "Number of bytes dont match, expected "+string(len(buf2))+" got "+string(m), err)
+                return
+        }
+        hexBuf1 := fmt.Sprintf("%02x", buf[len(buf)-100:])
+        hexBuf2 := fmt.Sprintf("%02x", buf2[:m])
+        if hexBuf1 != hexBuf2 {
+                logError(testName, function, args, startTime, "", "Values at same index dont match", err)
+                return
+        }
+        pos, err = r.Seek(-100, 2)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Object Seek failed", err)
+                return
+        }
+        if pos != st.Size-100 {
+                logError(testName, function, args, startTime, "", "Incorrect position", err)
+                return
+        }
+        if err = r.Close(); err != nil {
+                logError(testName, function, args, startTime, "", "ObjectClose failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test get object reader to not throw error on being closed twice.
+func testGetObjectClosedTwice() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(bucketName, objectName)"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Generate 33K of data.
+        bufSize := dataFileMap["datafile-33-kB"]
+        reader := getDataReader("datafile-33-kB")
+        defer reader.Close()
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes in stat does not match, expected "+string(int64(bufSize))+" got "+string(st.Size), err)
+                return
+        }
+        if err := crcMatchesName(r, "datafile-33-kB"); err != nil {
+                logError(testName, function, args, startTime, "", "data CRC check failed", err)
+                return
+        }
+        if err := r.Close(); err != nil {
+                logError(testName, function, args, startTime, "", "Object Close failed", err)
+                return
+        }
+        if err := r.Close(); err == nil {
+                logError(testName, function, args, startTime, "", "Already closed object. No error returned", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test RemoveObjects request where context cancels after timeout
+func testRemoveObjectsContext() {
+        // Initialize logging params.
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "RemoveObjects(ctx, bucketName, objectsCh)"
+        args := map[string]interface{}{
+                "bucketName": "",
+        }
+
+        // Seed random based on current tie.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+        // Enable tracing, write to stdout.
+        // c.TraceOn(os.Stderr)
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Generate put data.
+        r := bytes.NewReader(bytes.Repeat([]byte("a"), 8))
+
+        // Multi remove of 20 objects.
+        nrObjects := 20
+        objectsCh := make(chan minio.ObjectInfo)
+        go func() {
+                defer close(objectsCh)
+                for i := 0; i < nrObjects; i++ {
+                        objectName := "sample" + strconv.Itoa(i) + ".txt"
+                        info, err := c.PutObject(context.Background(), bucketName, objectName, r, 8,
+                                minio.PutObjectOptions{ContentType: "application/octet-stream"})
+                        if err != nil {
+                                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                                continue
+                        }
+                        objectsCh <- minio.ObjectInfo{
+                                Key:       info.Key,
+                                VersionID: info.VersionID,
+                        }
+                }
+        }()
+        // Set context to cancel in 1 nanosecond.
+        ctx, cancel := context.WithTimeout(context.Background(), 1*time.Nanosecond)
+        args["ctx"] = ctx
+        defer cancel()
+
+        // Call RemoveObjects API with short timeout.
+        errorCh := c.RemoveObjects(ctx, bucketName, objectsCh, minio.RemoveObjectsOptions{})
+        // Check for error.
+        select {
+        case r := <-errorCh:
+                if r.Err == nil {
+                        logError(testName, function, args, startTime, "", "RemoveObjects should fail on short timeout", err)
+                        return
+                }
+        }
+        // Set context with longer timeout.
+        ctx, cancel = context.WithTimeout(context.Background(), 1*time.Hour)
+        args["ctx"] = ctx
+        defer cancel()
+        // Perform RemoveObjects with the longer timeout. Expect the removals to succeed.
+        errorCh = c.RemoveObjects(ctx, bucketName, objectsCh, minio.RemoveObjectsOptions{})
+        select {
+        case r, more := <-errorCh:
+                if more || r.Err != nil {
+                        logError(testName, function, args, startTime, "", "Unexpected error", r.Err)
+                        return
+                }
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test removing multiple objects with Remove API
+func testRemoveMultipleObjects() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "RemoveObjects(bucketName, objectsCh)"
+        args := map[string]interface{}{
+                "bucketName": "",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Enable tracing, write to stdout.
+        // c.TraceOn(os.Stderr)
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        r := bytes.NewReader(bytes.Repeat([]byte("a"), 8))
+
+        // Multi remove of 1100 objects
+        nrObjects := 200
+
+        objectsCh := make(chan minio.ObjectInfo)
+
+        go func() {
+                defer close(objectsCh)
+                // Upload objects and send them to objectsCh
+                for i := 0; i < nrObjects; i++ {
+                        objectName := "sample" + strconv.Itoa(i) + ".txt"
+                        info, err := c.PutObject(context.Background(), bucketName, objectName, r, 8,
+                                minio.PutObjectOptions{ContentType: "application/octet-stream"})
+                        if err != nil {
+                                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                                continue
+                        }
+                        objectsCh <- minio.ObjectInfo{
+                                Key:       info.Key,
+                                VersionID: info.VersionID,
+                        }
+                }
+        }()
+
+        // Call RemoveObjects API
+        errorCh := c.RemoveObjects(context.Background(), bucketName, objectsCh, minio.RemoveObjectsOptions{})
+
+        // Check if errorCh doesn't receive any error
+        select {
+        case r, more := <-errorCh:
+                if more {
+                        logError(testName, function, args, startTime, "", "Unexpected error", r.Err)
+                        return
+                }
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test removing multiple objects and check for results
+func testRemoveMultipleObjectsWithResult() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "RemoveObjects(bucketName, objectsCh)"
+        args := map[string]interface{}{
+                "bucketName": "",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Enable tracing, write to stdout.
+        // c.TraceOn(os.Stderr)
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupVersionedBucket(bucketName, c)
+
+        r := bytes.NewReader(bytes.Repeat([]byte("a"), 8))
+
+        nrObjects := 10
+        nrLockedObjects := 5
+
+        objectsCh := make(chan minio.ObjectInfo)
+
+        go func() {
+                defer close(objectsCh)
+                // Upload objects and send them to objectsCh
+                for i := 0; i < nrObjects; i++ {
+                        objectName := "sample" + strconv.Itoa(i) + ".txt"
+                        info, err := c.PutObject(context.Background(), bucketName, objectName, r, 8,
+                                minio.PutObjectOptions{ContentType: "application/octet-stream"})
+                        if err != nil {
+                                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                                return
+                        }
+                        if i < nrLockedObjects {
+                                // t := time.Date(2130, time.April, 25, 14, 0, 0, 0, time.UTC)
+                                t := time.Now().Add(5 * time.Minute)
+                                m := minio.RetentionMode(minio.Governance)
+                                opts := minio.PutObjectRetentionOptions{
+                                        GovernanceBypass: false,
+                                        RetainUntilDate:  &t,
+                                        Mode:             &m,
+                                        VersionID:        info.VersionID,
+                                }
+                                err = c.PutObjectRetention(context.Background(), bucketName, objectName, opts)
+                                if err != nil {
+                                        logError(testName, function, args, startTime, "", "Error setting retention", err)
+                                        return
+                                }
+                        }
+
+                        objectsCh <- minio.ObjectInfo{
+                                Key:       info.Key,
+                                VersionID: info.VersionID,
+                        }
+                }
+        }()
+
+        // Call RemoveObjects API
+        resultCh := c.RemoveObjectsWithResult(context.Background(), bucketName, objectsCh, minio.RemoveObjectsOptions{})
+
+        var foundNil, foundErr int
+
+        for {
+                // Check if errorCh doesn't receive any error
+                select {
+                case deleteRes, ok := <-resultCh:
+                        if !ok {
+                                goto out
+                        }
+                        if deleteRes.ObjectName == "" {
+                                logError(testName, function, args, startTime, "", "Unexpected object name", nil)
+                                return
+                        }
+                        if deleteRes.ObjectVersionID == "" {
+                                logError(testName, function, args, startTime, "", "Unexpected object version ID", nil)
+                                return
+                        }
+
+                        if deleteRes.Err == nil {
+                                foundNil++
+                        } else {
+                                foundErr++
+                        }
+                }
+        }
+out:
+        if foundNil+foundErr != nrObjects {
+                logError(testName, function, args, startTime, "", "Unexpected number of results", nil)
+                return
+        }
+
+        if foundNil != nrObjects-nrLockedObjects {
+                logError(testName, function, args, startTime, "", "Unexpected number of nil errors", nil)
+                return
+        }
+
+        if foundErr != nrLockedObjects {
+                logError(testName, function, args, startTime, "", "Unexpected number of errors", nil)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests FPutObject of a big file to trigger multipart
+func testFPutObjectMultipart() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "FPutObject(bucketName, objectName, fileName, opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "fileName":   "",
+                "opts":       "",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Upload 4 parts to utilize all 3 'workers' in multipart and still have a part to upload.
+        fileName := getMintDataDirFilePath("datafile-129-MB")
+        if fileName == "" {
+                // Make a temp file with minPartSize bytes of data.
+                file, err := os.CreateTemp(os.TempDir(), "FPutObjectTest")
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "TempFile creation failed", err)
+                        return
+                }
+                // Upload 2 parts to utilize all 3 'workers' in multipart and still have a part to upload.
+                if _, err = io.Copy(file, getDataReader("datafile-129-MB")); err != nil {
+                        logError(testName, function, args, startTime, "", "Copy failed", err)
+                        return
+                }
+                if err = file.Close(); err != nil {
+                        logError(testName, function, args, startTime, "", "File Close failed", err)
+                        return
+                }
+                fileName = file.Name()
+                args["fileName"] = fileName
+        }
+        totalSize := dataFileMap["datafile-129-MB"]
+        // Set base object name
+        objectName := bucketName + "FPutObject" + "-standard"
+        args["objectName"] = objectName
+
+        objectContentType := "testapplication/octet-stream"
+        args["objectContentType"] = objectContentType
+
+        // Perform standard FPutObject with contentType provided (Expecting application/octet-stream)
+        _, err = c.FPutObject(context.Background(), bucketName, objectName, fileName, minio.PutObjectOptions{ContentType: objectContentType})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "FPutObject failed", err)
+                return
+        }
+
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+        objInfo, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Unexpected error", err)
+                return
+        }
+        if objInfo.Size != int64(totalSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes does not match, expected "+string(int64(totalSize))+" got "+string(objInfo.Size), err)
+                return
+        }
+        if objInfo.ContentType != objectContentType && objInfo.ContentType != "application/octet-stream" {
+                logError(testName, function, args, startTime, "", "ContentType doesn't match", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests FPutObject with null contentType (default = application/octet-stream)
+func testFPutObject() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "FPutObject(bucketName, objectName, fileName, opts)"
+
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "fileName":   "",
+                "opts":       "",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        location := "us-east-1"
+
+        // Make a new bucket.
+        args["bucketName"] = bucketName
+        args["location"] = location
+        function = "MakeBucket(bucketName, location)"
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: location})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Upload 3 parts worth of data to use all 3 of multiparts 'workers' and have an extra part.
+        // Use different data in part for multipart tests to check parts are uploaded in correct order.
+        fName := getMintDataDirFilePath("datafile-129-MB")
+        if fName == "" {
+                // Make a temp file with minPartSize bytes of data.
+                file, err := os.CreateTemp(os.TempDir(), "FPutObjectTest")
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "TempFile creation failed", err)
+                        return
+                }
+
+                // Upload 3 parts to utilize all 3 'workers' in multipart and still have a part to upload.
+                if _, err = io.Copy(file, getDataReader("datafile-129-MB")); err != nil {
+                        logError(testName, function, args, startTime, "", "File copy failed", err)
+                        return
+                }
+                // Close the file pro-actively for windows.
+                if err = file.Close(); err != nil {
+                        logError(testName, function, args, startTime, "", "File close failed", err)
+                        return
+                }
+                defer os.Remove(file.Name())
+                fName = file.Name()
+        }
+
+        // Set base object name
+        function = "FPutObject(bucketName, objectName, fileName, opts)"
+        objectName := bucketName + "FPutObject"
+        args["objectName"] = objectName + "-standard"
+        args["fileName"] = fName
+        args["opts"] = minio.PutObjectOptions{ContentType: "application/octet-stream"}
+
+        // Perform standard FPutObject with contentType provided (Expecting application/octet-stream)
+        ui, err := c.FPutObject(context.Background(), bucketName, objectName+"-standard", fName, minio.PutObjectOptions{ContentType: "application/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "FPutObject failed", err)
+                return
+        }
+
+        if ui.Size != int64(dataFileMap["datafile-129-MB"]) {
+                logError(testName, function, args, startTime, "", "FPutObject returned an unexpected upload size", err)
+                return
+        }
+
+        // Perform FPutObject with no contentType provided (Expecting application/octet-stream)
+        args["objectName"] = objectName + "-Octet"
+        _, err = c.FPutObject(context.Background(), bucketName, objectName+"-Octet", fName, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "File close failed", err)
+                return
+        }
+
+        srcFile, err := os.Open(fName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "File open failed", err)
+                return
+        }
+        defer srcFile.Close()
+        // Add extension to temp file name
+        tmpFile, err := os.Create(fName + ".gtar")
+        if err != nil {
+                logError(testName, function, args, startTime, "", "File create failed", err)
+                return
+        }
+        _, err = io.Copy(tmpFile, srcFile)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "File copy failed", err)
+                return
+        }
+        tmpFile.Close()
+
+        // Perform FPutObject with no contentType provided (Expecting application/x-gtar)
+        args["objectName"] = objectName + "-GTar"
+        args["opts"] = minio.PutObjectOptions{}
+        _, err = c.FPutObject(context.Background(), bucketName, objectName+"-GTar", fName+".gtar", minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "FPutObject failed", err)
+                return
+        }
+
+        // Check headers
+        function = "StatObject(bucketName, objectName, opts)"
+        args["objectName"] = objectName + "-standard"
+        rStandard, err := c.StatObject(context.Background(), bucketName, objectName+"-standard", minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+        if rStandard.ContentType != "application/octet-stream" {
+                logError(testName, function, args, startTime, "", "ContentType does not match, expected application/octet-stream, got "+rStandard.ContentType, err)
+                return
+        }
+
+        function = "StatObject(bucketName, objectName, opts)"
+        args["objectName"] = objectName + "-Octet"
+        rOctet, err := c.StatObject(context.Background(), bucketName, objectName+"-Octet", minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+        if rOctet.ContentType != "application/octet-stream" {
+                logError(testName, function, args, startTime, "", "ContentType does not match, expected application/octet-stream, got "+rOctet.ContentType, err)
+                return
+        }
+
+        function = "StatObject(bucketName, objectName, opts)"
+        args["objectName"] = objectName + "-GTar"
+        rGTar, err := c.StatObject(context.Background(), bucketName, objectName+"-GTar", minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+        if rGTar.ContentType != "application/x-gtar" && rGTar.ContentType != "application/octet-stream" && rGTar.ContentType != "application/x-tar" {
+                logError(testName, function, args, startTime, "", "ContentType does not match, expected application/x-tar or application/octet-stream, got "+rGTar.ContentType, err)
+                return
+        }
+
+        os.Remove(fName + ".gtar")
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests FPutObject request when context cancels after timeout
+func testFPutObjectContext() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "FPutObject(bucketName, objectName, fileName, opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "fileName":   "",
+                "opts":       "",
+        }
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Upload 1 parts worth of data to use multipart upload.
+        // Use different data in part for multipart tests to check parts are uploaded in correct order.
+        fName := getMintDataDirFilePath("datafile-1-MB")
+        if fName == "" {
+                // Make a temp file with 1 MiB bytes of data.
+                file, err := os.CreateTemp(os.TempDir(), "FPutObjectContextTest")
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "TempFile creation failed", err)
+                        return
+                }
+
+                // Upload 1 parts to trigger multipart upload
+                if _, err = io.Copy(file, getDataReader("datafile-1-MB")); err != nil {
+                        logError(testName, function, args, startTime, "", "File copy failed", err)
+                        return
+                }
+                // Close the file pro-actively for windows.
+                if err = file.Close(); err != nil {
+                        logError(testName, function, args, startTime, "", "File close failed", err)
+                        return
+                }
+                defer os.Remove(file.Name())
+                fName = file.Name()
+        }
+
+        // Set base object name
+        objectName := bucketName + "FPutObjectContext"
+        args["objectName"] = objectName
+        ctx, cancel := context.WithTimeout(context.Background(), 1*time.Nanosecond)
+        args["ctx"] = ctx
+        defer cancel()
+
+        // Perform FPutObject with contentType provided (Expecting application/octet-stream)
+        _, err = c.FPutObject(ctx, bucketName, objectName+"-Shorttimeout", fName, minio.PutObjectOptions{ContentType: "application/octet-stream"})
+        if err == nil {
+                logError(testName, function, args, startTime, "", "FPutObject should fail on short timeout", err)
+                return
+        }
+        ctx, cancel = context.WithTimeout(context.Background(), 1*time.Hour)
+        defer cancel()
+        // Perform FPutObject with a long timeout. Expect the put object to succeed
+        _, err = c.FPutObject(ctx, bucketName, objectName+"-Longtimeout", fName, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "FPutObject shouldn't fail on long timeout", err)
+                return
+        }
+
+        _, err = c.StatObject(context.Background(), bucketName, objectName+"-Longtimeout", minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests FPutObject request when context cancels after timeout
+func testFPutObjectContextV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "FPutObjectContext(ctx, bucketName, objectName, fileName, opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "opts":       "minio.PutObjectOptions{ContentType:objectContentType}",
+        }
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Upload 1 parts worth of data to use multipart upload.
+        // Use different data in part for multipart tests to check parts are uploaded in correct order.
+        fName := getMintDataDirFilePath("datafile-1-MB")
+        if fName == "" {
+                // Make a temp file with 1 MiB bytes of data.
+                file, err := os.CreateTemp(os.TempDir(), "FPutObjectContextTest")
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "Temp file creation failed", err)
+                        return
+                }
+
+                // Upload 1 parts to trigger multipart upload
+                if _, err = io.Copy(file, getDataReader("datafile-1-MB")); err != nil {
+                        logError(testName, function, args, startTime, "", "File copy failed", err)
+                        return
+                }
+
+                // Close the file pro-actively for windows.
+                if err = file.Close(); err != nil {
+                        logError(testName, function, args, startTime, "", "File close failed", err)
+                        return
+                }
+                defer os.Remove(file.Name())
+                fName = file.Name()
+        }
+
+        // Set base object name
+        objectName := bucketName + "FPutObjectContext"
+        args["objectName"] = objectName
+
+        ctx, cancel := context.WithTimeout(context.Background(), 1*time.Nanosecond)
+        args["ctx"] = ctx
+        defer cancel()
+
+        // Perform FPutObject with contentType provided (Expecting application/octet-stream)
+        _, err = c.FPutObject(ctx, bucketName, objectName+"-Shorttimeout", fName, minio.PutObjectOptions{ContentType: "application/octet-stream"})
+        if err == nil {
+                logError(testName, function, args, startTime, "", "FPutObject should fail on short timeout", err)
+                return
+        }
+        ctx, cancel = context.WithTimeout(context.Background(), 1*time.Hour)
+        defer cancel()
+        // Perform FPutObject with a long timeout. Expect the put object to succeed
+        _, err = c.FPutObject(ctx, bucketName, objectName+"-Longtimeout", fName, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "FPutObject shouldn't fail on longer timeout", err)
+                return
+        }
+
+        _, err = c.StatObject(context.Background(), bucketName, objectName+"-Longtimeout", minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test validates putObject with context to see if request cancellation is honored.
+func testPutObjectContext() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(ctx, bucketName, objectName, fileName, opts)"
+        args := map[string]interface{}{
+                "ctx":        "",
+                "bucketName": "",
+                "objectName": "",
+                "opts":       "",
+        }
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Make a new bucket.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket call failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        bufSize := dataFileMap["datafile-33-kB"]
+        reader := getDataReader("datafile-33-kB")
+        defer reader.Close()
+        objectName := fmt.Sprintf("test-file-%v", rand.Uint32())
+        args["objectName"] = objectName
+
+        ctx, cancel := context.WithTimeout(context.Background(), 1*time.Nanosecond)
+        cancel()
+        args["ctx"] = ctx
+        args["opts"] = minio.PutObjectOptions{ContentType: "binary/octet-stream"}
+
+        _, err = c.PutObject(ctx, bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err == nil {
+                logError(testName, function, args, startTime, "", "PutObject should fail on short timeout", err)
+                return
+        }
+
+        ctx, cancel = context.WithTimeout(context.Background(), 1*time.Hour)
+        args["ctx"] = ctx
+
+        defer cancel()
+        reader = getDataReader("datafile-33-kB")
+        defer reader.Close()
+        _, err = c.PutObject(ctx, bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject with long timeout failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests get object with s3zip extensions.
+func testGetObjectS3Zip() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(bucketName, objectName)"
+        args := map[string]interface{}{"x-minio-extract": true}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer func() {
+                // Delete all objects and buckets
+                if err = cleanupBucket(bucketName, c); err != nil {
+                        logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                        return
+                }
+        }()
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "") + ".zip"
+        args["objectName"] = objectName
+
+        var zipFile bytes.Buffer
+        zw := zip.NewWriter(&zipFile)
+        rng := rand.New(rand.NewSource(0xc0cac01a))
+        const nFiles = 500
+        for i := 0; i <= nFiles; i++ {
+                if i == nFiles {
+                        // Make one large, compressible file.
+                        i = 1000000
+                }
+                b := make([]byte, i)
+                if i < nFiles {
+                        rng.Read(b)
+                }
+                wc, err := zw.Create(fmt.Sprintf("test/small/file-%d.bin", i))
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "zw.Create failed", err)
+                        return
+                }
+                wc.Write(b)
+        }
+        err = zw.Close()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "zw.Close failed", err)
+                return
+        }
+        buf := zipFile.Bytes()
+
+        // Save the data
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat object failed", err)
+                return
+        }
+
+        if st.Size != int64(len(buf)) {
+                logError(testName, function, args, startTime, "", "Number of bytes does not match, expected "+string(len(buf))+", got "+string(st.Size), err)
+                return
+        }
+        r.Close()
+
+        zr, err := zip.NewReader(bytes.NewReader(buf), int64(len(buf)))
+        if err != nil {
+                logError(testName, function, args, startTime, "", "zip.NewReader failed", err)
+                return
+        }
+        lOpts := minio.ListObjectsOptions{}
+        lOpts.Set("x-minio-extract", "true")
+        lOpts.Prefix = objectName + "/"
+        lOpts.Recursive = true
+        list := c.ListObjects(context.Background(), bucketName, lOpts)
+        listed := map[string]minio.ObjectInfo{}
+        for item := range list {
+                if item.Err != nil {
+                        break
+                }
+                listed[item.Key] = item
+        }
+        if len(listed) == 0 {
+                // Assume we are running against non-minio.
+                args["SKIPPED"] = true
+                ignoredLog(testName, function, args, startTime, "s3zip does not appear to be present").Info()
+                return
+        }
+
+        for _, file := range zr.File {
+                if file.FileInfo().IsDir() {
+                        continue
+                }
+                args["zipfile"] = file.Name
+                zfr, err := file.Open()
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "file.Open failed", err)
+                        return
+                }
+                want, err := io.ReadAll(zfr)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "fzip file read failed", err)
+                        return
+                }
+
+                opts := minio.GetObjectOptions{}
+                opts.Set("x-minio-extract", "true")
+                key := path.Join(objectName, file.Name)
+                r, err = c.GetObject(context.Background(), bucketName, key, opts)
+                if err != nil {
+                        terr := minio.ToErrorResponse(err)
+                        if terr.StatusCode != http.StatusNotFound {
+                                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                        }
+                        return
+                }
+                got, err := io.ReadAll(r)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                        return
+                }
+                r.Close()
+                if !bytes.Equal(want, got) {
+                        logError(testName, function, args, startTime, "", "Content mismatch", err)
+                        return
+                }
+                oi, ok := listed[key]
+                if !ok {
+                        logError(testName, function, args, startTime, "", "Object Missing", fmt.Errorf("%s not present in listing", key))
+                        return
+                }
+                if int(oi.Size) != len(got) {
+                        logError(testName, function, args, startTime, "", "Object Size Incorrect", fmt.Errorf("listing %d, read %d", oi.Size, len(got)))
+                        return
+                }
+                delete(listed, key)
+        }
+        delete(args, "zipfile")
+        if len(listed) > 0 {
+                logError(testName, function, args, startTime, "", "Extra listed objects", fmt.Errorf("left over: %v", listed))
+                return
+        }
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests get object ReaderSeeker interface methods.
+func testGetObjectReadSeekFunctional() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(bucketName, objectName)"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer func() {
+                // Delete all objects and buckets
+                if err = cleanupBucket(bucketName, c); err != nil {
+                        logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                        return
+                }
+        }()
+
+        // Generate 33K of data.
+        bufSize := dataFileMap["datafile-33-kB"]
+        reader := getDataReader("datafile-33-kB")
+        defer reader.Close()
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        buf, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+
+        // Save the data
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat object failed", err)
+                return
+        }
+
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes does not match, expected "+string(int64(bufSize))+", got "+string(st.Size), err)
+                return
+        }
+
+        // This following function helps us to compare data from the reader after seek
+        // with the data from the original buffer
+        cmpData := func(r io.Reader, start, end int) {
+                if end-start == 0 {
+                        return
+                }
+                buffer := bytes.NewBuffer([]byte{})
+                if _, err := io.CopyN(buffer, r, int64(bufSize)); err != nil {
+                        if err != io.EOF {
+                                logError(testName, function, args, startTime, "", "CopyN failed", err)
+                                return
+                        }
+                }
+                if !bytes.Equal(buf[start:end], buffer.Bytes()) {
+                        logError(testName, function, args, startTime, "", "Incorrect read bytes v/s original buffer", err)
+                        return
+                }
+        }
+
+        // Generic seek error for errors other than io.EOF
+        seekErr := errors.New("seek error")
+
+        testCases := []struct {
+                offset    int64
+                whence    int
+                pos       int64
+                err       error
+                shouldCmp bool
+                start     int
+                end       int
+        }{
+                // Start from offset 0, fetch data and compare
+                {0, 0, 0, nil, true, 0, 0},
+                // Start from offset 2048, fetch data and compare
+                {2048, 0, 2048, nil, true, 2048, bufSize},
+                // Start from offset larger than possible
+                {int64(bufSize) + 1024, 0, 0, seekErr, false, 0, 0},
+                // Move to offset 0 without comparing
+                {0, 0, 0, nil, false, 0, 0},
+                // Move one step forward and compare
+                {1, 1, 1, nil, true, 1, bufSize},
+                // Move larger than possible
+                {int64(bufSize), 1, 0, seekErr, false, 0, 0},
+                // Provide negative offset with CUR_SEEK
+                {int64(-1), 1, 0, seekErr, false, 0, 0},
+                // Test with whence SEEK_END and with positive offset
+                {1024, 2, int64(bufSize) - 1024, io.EOF, true, 0, 0},
+                // Test with whence SEEK_END and with negative offset
+                {-1024, 2, int64(bufSize) - 1024, nil, true, bufSize - 1024, bufSize},
+                // Test with whence SEEK_END and with large negative offset
+                {-int64(bufSize) * 2, 2, 0, seekErr, true, 0, 0},
+        }
+
+        for i, testCase := range testCases {
+                // Perform seek operation
+                n, err := r.Seek(testCase.offset, testCase.whence)
+                // We expect an error
+                if testCase.err == seekErr && err == nil {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", unexpected err value: expected: "+testCase.err.Error()+", found: "+err.Error(), err)
+                        return
+                }
+                // We expect a specific error
+                if testCase.err != seekErr && testCase.err != err {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", unexpected err value: expected: "+testCase.err.Error()+", found: "+err.Error(), err)
+                        return
+                }
+                // If we expect an error go to the next loop
+                if testCase.err != nil {
+                        continue
+                }
+                // Check the returned seek pos
+                if n != testCase.pos {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", number of bytes seeked does not match, expected "+string(testCase.pos)+", got "+string(n), err)
+                        return
+                }
+                // Compare only if shouldCmp is activated
+                if testCase.shouldCmp {
+                        cmpData(r, testCase.start, testCase.end)
+                }
+        }
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests get object ReaderAt interface methods.
+func testGetObjectReadAtFunctional() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(bucketName, objectName)"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Generate 33K of data.
+        bufSize := dataFileMap["datafile-33-kB"]
+        reader := getDataReader("datafile-33-kB")
+        defer reader.Close()
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        buf, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+
+        // Save the data
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+        offset := int64(2048)
+
+        // read directly
+        buf1 := make([]byte, 512)
+        buf2 := make([]byte, 512)
+        buf3 := make([]byte, 512)
+        buf4 := make([]byte, 512)
+
+        // Test readAt before stat is called such that objectInfo doesn't change.
+        m, err := r.ReadAt(buf1, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf1) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf1))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf1, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+        offset += 512
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes in stat does not match, expected "+string(int64(bufSize))+", got "+string(st.Size), err)
+                return
+        }
+
+        m, err = r.ReadAt(buf2, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf2) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf2))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf2, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+
+        offset += 512
+        m, err = r.ReadAt(buf3, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf3) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf3))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf3, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+        offset += 512
+        m, err = r.ReadAt(buf4, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf4) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf4))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf4, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+
+        buf5 := make([]byte, len(buf))
+        // Read the whole object.
+        m, err = r.ReadAt(buf5, 0)
+        if err != nil {
+                if err != io.EOF {
+                        logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                        return
+                }
+        }
+        if m != len(buf5) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf5))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf, buf5) {
+                logError(testName, function, args, startTime, "", "Incorrect data read in GetObject, than what was previously uploaded", err)
+                return
+        }
+
+        buf6 := make([]byte, len(buf)+1)
+        // Read the whole object and beyond.
+        _, err = r.ReadAt(buf6, 0)
+        if err != nil {
+                if err != io.EOF {
+                        logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                        return
+                }
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Reproduces issue https://github.com/minio/minio-go/issues/1137
+func testGetObjectReadAtWhenEOFWasReached() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(bucketName, objectName)"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Generate 33K of data.
+        bufSize := dataFileMap["datafile-33-kB"]
+        reader := getDataReader("datafile-33-kB")
+        defer reader.Close()
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        buf, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+
+        // Save the data
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // read directly
+        buf1 := make([]byte, len(buf))
+        buf2 := make([]byte, 512)
+
+        m, err := r.Read(buf1)
+        if err != nil {
+                if err != io.EOF {
+                        logError(testName, function, args, startTime, "", "Read failed", err)
+                        return
+                }
+        }
+        if m != len(buf1) {
+                logError(testName, function, args, startTime, "", "Read read shorter bytes before reaching EOF, expected "+string(len(buf1))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf1, buf) {
+                logError(testName, function, args, startTime, "", "Incorrect count of Read data", err)
+                return
+        }
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes in stat does not match, expected "+string(int64(bufSize))+", got "+string(st.Size), err)
+                return
+        }
+
+        m, err = r.ReadAt(buf2, 512)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf2) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf2))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf2, buf[512:1024]) {
+                logError(testName, function, args, startTime, "", "Incorrect count of ReadAt data", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test Presigned Post Policy
+func testPresignedPostPolicy() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PresignedPostPolicy(policy)"
+        args := map[string]interface{}{
+                "policy": "",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        // Make a new bucket in 'us-east-1' (source bucket).
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Generate 33K of data.
+        reader := getDataReader("datafile-33-kB")
+        defer reader.Close()
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        // Azure requires the key to not start with a number
+        metadataKey := randString(60, rand.NewSource(time.Now().UnixNano()), "user")
+        metadataValue := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+
+        buf, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+
+        // Save the data
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        policy := minio.NewPostPolicy()
+
+        if err := policy.SetBucket(""); err == nil {
+                logError(testName, function, args, startTime, "", "SetBucket did not fail for invalid conditions", err)
+                return
+        }
+        if err := policy.SetKey(""); err == nil {
+                logError(testName, function, args, startTime, "", "SetKey did not fail for invalid conditions", err)
+                return
+        }
+        if err := policy.SetExpires(time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC)); err == nil {
+                logError(testName, function, args, startTime, "", "SetExpires did not fail for invalid conditions", err)
+                return
+        }
+        if err := policy.SetContentType(""); err == nil {
+                logError(testName, function, args, startTime, "", "SetContentType did not fail for invalid conditions", err)
+                return
+        }
+        if err := policy.SetContentLengthRange(1024*1024, 1024); err == nil {
+                logError(testName, function, args, startTime, "", "SetContentLengthRange did not fail for invalid conditions", err)
+                return
+        }
+        if err := policy.SetUserMetadata("", ""); err == nil {
+                logError(testName, function, args, startTime, "", "SetUserMetadata did not fail for invalid conditions", err)
+                return
+        }
+
+        policy.SetBucket(bucketName)
+        policy.SetKey(objectName)
+        policy.SetExpires(time.Now().UTC().AddDate(0, 0, 10)) // expires in 10 days
+        policy.SetContentType("binary/octet-stream")
+        policy.SetContentLengthRange(10, 1024*1024)
+        policy.SetUserMetadata(metadataKey, metadataValue)
+
+        // Add CRC32C
+        checksum := minio.ChecksumCRC32C.ChecksumBytes(buf)
+        policy.SetChecksum(checksum)
+
+        args["policy"] = policy.String()
+
+        presignedPostPolicyURL, formData, err := c.PresignedPostPolicy(context.Background(), policy)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedPostPolicy failed", err)
+                return
+        }
+
+        var formBuf bytes.Buffer
+        writer := multipart.NewWriter(&formBuf)
+        for k, v := range formData {
+                writer.WriteField(k, v)
+        }
+
+        // Get a 33KB file to upload and test if set post policy works
+        filePath := getMintDataDirFilePath("datafile-33-kB")
+        if filePath == "" {
+                // Make a temp file with 33 KB data.
+                file, err := os.CreateTemp(os.TempDir(), "PresignedPostPolicyTest")
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "TempFile creation failed", err)
+                        return
+                }
+                if _, err = io.Copy(file, getDataReader("datafile-33-kB")); err != nil {
+                        logError(testName, function, args, startTime, "", "Copy failed", err)
+                        return
+                }
+                if err = file.Close(); err != nil {
+                        logError(testName, function, args, startTime, "", "File Close failed", err)
+                        return
+                }
+                filePath = file.Name()
+        }
+
+        // add file to post request
+        f, err := os.Open(filePath)
+        defer f.Close()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "File open failed", err)
+                return
+        }
+        w, err := writer.CreateFormFile("file", filePath)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CreateFormFile failed", err)
+                return
+        }
+
+        _, err = io.Copy(w, f)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Copy failed", err)
+                return
+        }
+        writer.Close()
+
+        transport, err := minio.DefaultTransport(mustParseBool(os.Getenv(enableHTTPS)))
+        if err != nil {
+                logError(testName, function, args, startTime, "", "DefaultTransport failed", err)
+                return
+        }
+
+        httpClient := &http.Client{
+                // Setting a sensible time out of 30secs to wait for response
+                // headers. Request is pro-actively canceled after 30secs
+                // with no response.
+                Timeout:   30 * time.Second,
+                Transport: transport,
+        }
+        args["url"] = presignedPostPolicyURL.String()
+
+        req, err := http.NewRequest(http.MethodPost, presignedPostPolicyURL.String(), bytes.NewReader(formBuf.Bytes()))
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Http request failed", err)
+                return
+        }
+
+        req.Header.Set("Content-Type", writer.FormDataContentType())
+
+        // make post request with correct form data
+        res, err := httpClient.Do(req)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Http request failed", err)
+                return
+        }
+        defer res.Body.Close()
+        if res.StatusCode != http.StatusNoContent {
+                logError(testName, function, args, startTime, "", "Http request failed", errors.New(res.Status))
+                return
+        }
+
+        // expected path should be absolute path of the object
+        var scheme string
+        if mustParseBool(os.Getenv(enableHTTPS)) {
+                scheme = "https://"
+        } else {
+                scheme = "http://"
+        }
+
+        expectedLocation := scheme + os.Getenv(serverEndpoint) + "/" + bucketName + "/" + objectName
+        expectedLocationBucketDNS := scheme + bucketName + "." + os.Getenv(serverEndpoint) + "/" + objectName
+
+        if !strings.Contains(expectedLocation, "s3.amazonaws.com/") {
+                // Test when not against AWS S3.
+                if val, ok := res.Header["Location"]; ok {
+                        if val[0] != expectedLocation && val[0] != expectedLocationBucketDNS {
+                                logError(testName, function, args, startTime, "", fmt.Sprintf("Location in header response is incorrect. Want %q or %q, got %q", expectedLocation, expectedLocationBucketDNS, val[0]), err)
+                                return
+                        }
+                } else {
+                        logError(testName, function, args, startTime, "", "Location not found in header response", err)
+                        return
+                }
+        }
+        want := checksum.Encoded()
+        if got := res.Header.Get("X-Amz-Checksum-Crc32c"); got != want {
+                logError(testName, function, args, startTime, "", fmt.Sprintf("Want checksum %q, got %q", want, got), nil)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests copy object
+func testCopyObject() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(dst, src)"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        // Make a new bucket in 'us-east-1' (source bucket).
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Make a new bucket in 'us-east-1' (destination bucket).
+        err = c.MakeBucket(context.Background(), bucketName+"-copy", minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName+"-copy", c)
+
+        // Generate 33K of data.
+        bufSize := dataFileMap["datafile-33-kB"]
+        reader := getDataReader("datafile-33-kB")
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+        // Check the various fields of source object against destination object.
+        objInfo, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+
+        // Copy Source
+        src := minio.CopySrcOptions{
+                Bucket: bucketName,
+                Object: objectName,
+                // Set copy conditions.
+                MatchETag:          objInfo.ETag,
+                MatchModifiedSince: time.Date(2014, time.April, 0, 0, 0, 0, 0, time.UTC),
+        }
+        args["src"] = src
+
+        dst := minio.CopyDestOptions{
+                Bucket: bucketName + "-copy",
+                Object: objectName + "-copy",
+        }
+
+        // Perform the Copy
+        if _, err = c.CopyObject(context.Background(), dst, src); err != nil {
+                logError(testName, function, args, startTime, "", "CopyObject failed", err)
+                return
+        }
+
+        // Source object
+        r, err = c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+
+        // Destination object
+        readerCopy, err := c.GetObject(context.Background(), bucketName+"-copy", objectName+"-copy", minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+
+        // Check the various fields of source object against destination object.
+        objInfo, err = r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+        objInfoCopy, err := readerCopy.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+        if objInfo.Size != objInfoCopy.Size {
+                logError(testName, function, args, startTime, "", "Number of bytes does not match, expected "+string(objInfoCopy.Size)+", got "+string(objInfo.Size), err)
+                return
+        }
+
+        if err := crcMatchesName(r, "datafile-33-kB"); err != nil {
+                logError(testName, function, args, startTime, "", "data CRC check failed", err)
+                return
+        }
+        if err := crcMatchesName(readerCopy, "datafile-33-kB"); err != nil {
+                logError(testName, function, args, startTime, "", "copy data CRC check failed", err)
+                return
+        }
+        // Close all the get readers before proceeding with CopyObject operations.
+        r.Close()
+        readerCopy.Close()
+
+        // CopyObject again but with wrong conditions
+        src = minio.CopySrcOptions{
+                Bucket:               bucketName,
+                Object:               objectName,
+                MatchUnmodifiedSince: time.Date(2014, time.April, 0, 0, 0, 0, 0, time.UTC),
+                NoMatchETag:          objInfo.ETag,
+        }
+
+        // Perform the Copy which should fail
+        _, err = c.CopyObject(context.Background(), dst, src)
+        if err == nil {
+                logError(testName, function, args, startTime, "", "CopyObject did not fail for invalid conditions", err)
+                return
+        }
+
+        src = minio.CopySrcOptions{
+                Bucket: bucketName,
+                Object: objectName,
+        }
+
+        dst = minio.CopyDestOptions{
+                Bucket:          bucketName,
+                Object:          objectName,
+                ReplaceMetadata: true,
+                UserMetadata: map[string]string{
+                        "Copy": "should be same",
+                },
+        }
+        args["dst"] = dst
+        args["src"] = src
+
+        _, err = c.CopyObject(context.Background(), dst, src)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObject shouldn't fail", err)
+                return
+        }
+
+        oi, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+
+        stOpts := minio.StatObjectOptions{}
+        stOpts.SetMatchETag(oi.ETag)
+        objInfo, err = c.StatObject(context.Background(), bucketName, objectName, stOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObject ETag should match and not fail", err)
+                return
+        }
+
+        if objInfo.Metadata.Get("x-amz-meta-copy") != "should be same" {
+                logError(testName, function, args, startTime, "", "CopyObject modified metadata should match", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests SSE-C get object ReaderSeeker interface methods.
+func testSSECEncryptedGetObjectReadSeekFunctional() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(bucketName, objectName)"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer func() {
+                // Delete all objects and buckets
+                if err = cleanupBucket(bucketName, c); err != nil {
+                        logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                        return
+                }
+        }()
+
+        // Generate 129MiB of data.
+        bufSize := dataFileMap["datafile-129-MB"]
+        reader := getDataReader("datafile-129-MB")
+        defer reader.Close()
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        buf, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+
+        // Save the data
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{
+                ContentType:          "binary/octet-stream",
+                ServerSideEncryption: encrypt.DefaultPBKDF([]byte("correct horse battery staple"), []byte(bucketName+objectName)),
+        })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{
+                ServerSideEncryption: encrypt.DefaultPBKDF([]byte("correct horse battery staple"), []byte(bucketName+objectName)),
+        })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+        defer r.Close()
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat object failed", err)
+                return
+        }
+
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes does not match, expected "+string(int64(bufSize))+", got "+string(st.Size), err)
+                return
+        }
+
+        // This following function helps us to compare data from the reader after seek
+        // with the data from the original buffer
+        cmpData := func(r io.Reader, start, end int) {
+                if end-start == 0 {
+                        return
+                }
+                buffer := bytes.NewBuffer([]byte{})
+                if _, err := io.CopyN(buffer, r, int64(bufSize)); err != nil {
+                        if err != io.EOF {
+                                logError(testName, function, args, startTime, "", "CopyN failed", err)
+                                return
+                        }
+                }
+                if !bytes.Equal(buf[start:end], buffer.Bytes()) {
+                        logError(testName, function, args, startTime, "", "Incorrect read bytes v/s original buffer", err)
+                        return
+                }
+        }
+
+        testCases := []struct {
+                offset    int64
+                whence    int
+                pos       int64
+                err       error
+                shouldCmp bool
+                start     int
+                end       int
+        }{
+                // Start from offset 0, fetch data and compare
+                {0, 0, 0, nil, true, 0, 0},
+                // Start from offset 2048, fetch data and compare
+                {2048, 0, 2048, nil, true, 2048, bufSize},
+                // Start from offset larger than possible
+                {int64(bufSize) + 1024, 0, 0, io.EOF, false, 0, 0},
+                // Move to offset 0 without comparing
+                {0, 0, 0, nil, false, 0, 0},
+                // Move one step forward and compare
+                {1, 1, 1, nil, true, 1, bufSize},
+                // Move larger than possible
+                {int64(bufSize), 1, 0, io.EOF, false, 0, 0},
+                // Provide negative offset with CUR_SEEK
+                {int64(-1), 1, 0, fmt.Errorf("Negative position not allowed for 1"), false, 0, 0},
+                // Test with whence SEEK_END and with positive offset
+                {1024, 2, 0, io.EOF, false, 0, 0},
+                // Test with whence SEEK_END and with negative offset
+                {-1024, 2, int64(bufSize) - 1024, nil, true, bufSize - 1024, bufSize},
+                // Test with whence SEEK_END and with large negative offset
+                {-int64(bufSize) * 2, 2, 0, fmt.Errorf("Seeking at negative offset not allowed for 2"), false, 0, 0},
+                // Test with invalid whence
+                {0, 3, 0, fmt.Errorf("Invalid whence 3"), false, 0, 0},
+        }
+
+        for i, testCase := range testCases {
+                // Perform seek operation
+                n, err := r.Seek(testCase.offset, testCase.whence)
+                if err != nil && testCase.err == nil {
+                        // We expected success.
+                        logError(testName, function, args, startTime, "",
+                                fmt.Sprintf("Test %d, unexpected err value: expected: %s, found: %s", i+1, testCase.err, err), err)
+                        return
+                }
+                if err == nil && testCase.err != nil {
+                        // We expected failure, but got success.
+                        logError(testName, function, args, startTime, "",
+                                fmt.Sprintf("Test %d, unexpected err value: expected: %s, found: %s", i+1, testCase.err, err), err)
+                        return
+                }
+                if err != nil && testCase.err != nil {
+                        if err.Error() != testCase.err.Error() {
+                                // We expect a specific error
+                                logError(testName, function, args, startTime, "",
+                                        fmt.Sprintf("Test %d, unexpected err value: expected: %s, found: %s", i+1, testCase.err, err), err)
+                                return
+                        }
+                }
+                // Check the returned seek pos
+                if n != testCase.pos {
+                        logError(testName, function, args, startTime, "",
+                                fmt.Sprintf("Test %d, number of bytes seeked does not match, expected %d, got %d", i+1, testCase.pos, n), err)
+                        return
+                }
+                // Compare only if shouldCmp is activated
+                if testCase.shouldCmp {
+                        cmpData(r, testCase.start, testCase.end)
+                }
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests SSE-S3 get object ReaderSeeker interface methods.
+func testSSES3EncryptedGetObjectReadSeekFunctional() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(bucketName, objectName)"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer func() {
+                // Delete all objects and buckets
+                if err = cleanupBucket(bucketName, c); err != nil {
+                        logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                        return
+                }
+        }()
+
+        // Generate 129MiB of data.
+        bufSize := dataFileMap["datafile-129-MB"]
+        reader := getDataReader("datafile-129-MB")
+        defer reader.Close()
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        buf, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+
+        // Save the data
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{
+                ContentType:          "binary/octet-stream",
+                ServerSideEncryption: encrypt.NewSSE(),
+        })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+        defer r.Close()
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat object failed", err)
+                return
+        }
+
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes does not match, expected "+string(int64(bufSize))+", got "+string(st.Size), err)
+                return
+        }
+
+        // This following function helps us to compare data from the reader after seek
+        // with the data from the original buffer
+        cmpData := func(r io.Reader, start, end int) {
+                if end-start == 0 {
+                        return
+                }
+                buffer := bytes.NewBuffer([]byte{})
+                if _, err := io.CopyN(buffer, r, int64(bufSize)); err != nil {
+                        if err != io.EOF {
+                                logError(testName, function, args, startTime, "", "CopyN failed", err)
+                                return
+                        }
+                }
+                if !bytes.Equal(buf[start:end], buffer.Bytes()) {
+                        logError(testName, function, args, startTime, "", "Incorrect read bytes v/s original buffer", err)
+                        return
+                }
+        }
+
+        testCases := []struct {
+                offset    int64
+                whence    int
+                pos       int64
+                err       error
+                shouldCmp bool
+                start     int
+                end       int
+        }{
+                // Start from offset 0, fetch data and compare
+                {0, 0, 0, nil, true, 0, 0},
+                // Start from offset 2048, fetch data and compare
+                {2048, 0, 2048, nil, true, 2048, bufSize},
+                // Start from offset larger than possible
+                {int64(bufSize) + 1024, 0, 0, io.EOF, false, 0, 0},
+                // Move to offset 0 without comparing
+                {0, 0, 0, nil, false, 0, 0},
+                // Move one step forward and compare
+                {1, 1, 1, nil, true, 1, bufSize},
+                // Move larger than possible
+                {int64(bufSize), 1, 0, io.EOF, false, 0, 0},
+                // Provide negative offset with CUR_SEEK
+                {int64(-1), 1, 0, fmt.Errorf("Negative position not allowed for 1"), false, 0, 0},
+                // Test with whence SEEK_END and with positive offset
+                {1024, 2, 0, io.EOF, false, 0, 0},
+                // Test with whence SEEK_END and with negative offset
+                {-1024, 2, int64(bufSize) - 1024, nil, true, bufSize - 1024, bufSize},
+                // Test with whence SEEK_END and with large negative offset
+                {-int64(bufSize) * 2, 2, 0, fmt.Errorf("Seeking at negative offset not allowed for 2"), false, 0, 0},
+                // Test with invalid whence
+                {0, 3, 0, fmt.Errorf("Invalid whence 3"), false, 0, 0},
+        }
+
+        for i, testCase := range testCases {
+                // Perform seek operation
+                n, err := r.Seek(testCase.offset, testCase.whence)
+                if err != nil && testCase.err == nil {
+                        // We expected success.
+                        logError(testName, function, args, startTime, "",
+                                fmt.Sprintf("Test %d, unexpected err value: expected: %s, found: %s", i+1, testCase.err, err), err)
+                        return
+                }
+                if err == nil && testCase.err != nil {
+                        // We expected failure, but got success.
+                        logError(testName, function, args, startTime, "",
+                                fmt.Sprintf("Test %d, unexpected err value: expected: %s, found: %s", i+1, testCase.err, err), err)
+                        return
+                }
+                if err != nil && testCase.err != nil {
+                        if err.Error() != testCase.err.Error() {
+                                // We expect a specific error
+                                logError(testName, function, args, startTime, "",
+                                        fmt.Sprintf("Test %d, unexpected err value: expected: %s, found: %s", i+1, testCase.err, err), err)
+                                return
+                        }
+                }
+                // Check the returned seek pos
+                if n != testCase.pos {
+                        logError(testName, function, args, startTime, "",
+                                fmt.Sprintf("Test %d, number of bytes seeked does not match, expected %d, got %d", i+1, testCase.pos, n), err)
+                        return
+                }
+                // Compare only if shouldCmp is activated
+                if testCase.shouldCmp {
+                        cmpData(r, testCase.start, testCase.end)
+                }
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests SSE-C get object ReaderAt interface methods.
+func testSSECEncryptedGetObjectReadAtFunctional() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(bucketName, objectName)"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Generate 129MiB of data.
+        bufSize := dataFileMap["datafile-129-MB"]
+        reader := getDataReader("datafile-129-MB")
+        defer reader.Close()
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        buf, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+
+        // Save the data
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{
+                ContentType:          "binary/octet-stream",
+                ServerSideEncryption: encrypt.DefaultPBKDF([]byte("correct horse battery staple"), []byte(bucketName+objectName)),
+        })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{
+                ServerSideEncryption: encrypt.DefaultPBKDF([]byte("correct horse battery staple"), []byte(bucketName+objectName)),
+        })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+        defer r.Close()
+
+        offset := int64(2048)
+
+        // read directly
+        buf1 := make([]byte, 512)
+        buf2 := make([]byte, 512)
+        buf3 := make([]byte, 512)
+        buf4 := make([]byte, 512)
+
+        // Test readAt before stat is called such that objectInfo doesn't change.
+        m, err := r.ReadAt(buf1, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf1) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf1))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf1, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+        offset += 512
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes in stat does not match, expected "+string(int64(bufSize))+", got "+string(st.Size), err)
+                return
+        }
+
+        m, err = r.ReadAt(buf2, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf2) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf2))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf2, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+        offset += 512
+        m, err = r.ReadAt(buf3, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf3) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf3))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf3, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+        offset += 512
+        m, err = r.ReadAt(buf4, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf4) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf4))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf4, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+
+        buf5 := make([]byte, len(buf))
+        // Read the whole object.
+        m, err = r.ReadAt(buf5, 0)
+        if err != nil {
+                if err != io.EOF {
+                        logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                        return
+                }
+        }
+        if m != len(buf5) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf5))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf, buf5) {
+                logError(testName, function, args, startTime, "", "Incorrect data read in GetObject, than what was previously uploaded", err)
+                return
+        }
+
+        buf6 := make([]byte, len(buf)+1)
+        // Read the whole object and beyond.
+        _, err = r.ReadAt(buf6, 0)
+        if err != nil {
+                if err != io.EOF {
+                        logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                        return
+                }
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests SSE-S3 get object ReaderAt interface methods.
+func testSSES3EncryptedGetObjectReadAtFunctional() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(bucketName, objectName)"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Generate 129MiB of data.
+        bufSize := dataFileMap["datafile-129-MB"]
+        reader := getDataReader("datafile-129-MB")
+        defer reader.Close()
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        buf, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+
+        // Save the data
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{
+                ContentType:          "binary/octet-stream",
+                ServerSideEncryption: encrypt.NewSSE(),
+        })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+        defer r.Close()
+
+        offset := int64(2048)
+
+        // read directly
+        buf1 := make([]byte, 512)
+        buf2 := make([]byte, 512)
+        buf3 := make([]byte, 512)
+        buf4 := make([]byte, 512)
+
+        // Test readAt before stat is called such that objectInfo doesn't change.
+        m, err := r.ReadAt(buf1, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf1) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf1))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf1, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+        offset += 512
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes in stat does not match, expected "+string(int64(bufSize))+", got "+string(st.Size), err)
+                return
+        }
+
+        m, err = r.ReadAt(buf2, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf2) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf2))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf2, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+        offset += 512
+        m, err = r.ReadAt(buf3, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf3) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf3))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf3, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+        offset += 512
+        m, err = r.ReadAt(buf4, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf4) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf4))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf4, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+
+        buf5 := make([]byte, len(buf))
+        // Read the whole object.
+        m, err = r.ReadAt(buf5, 0)
+        if err != nil {
+                if err != io.EOF {
+                        logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                        return
+                }
+        }
+        if m != len(buf5) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf5))+", got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf, buf5) {
+                logError(testName, function, args, startTime, "", "Incorrect data read in GetObject, than what was previously uploaded", err)
+                return
+        }
+
+        buf6 := make([]byte, len(buf)+1)
+        // Read the whole object and beyond.
+        _, err = r.ReadAt(buf6, 0)
+        if err != nil {
+                if err != io.EOF {
+                        logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                        return
+                }
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// testSSECEncryptionPutGet tests encryption with customer provided encryption keys
+func testSSECEncryptionPutGet() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutEncryptedObject(bucketName, objectName, reader, sse)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "sse":        "",
+        }
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        testCases := []struct {
+                buf []byte
+        }{
+                {buf: bytes.Repeat([]byte("F"), 1)},
+                {buf: bytes.Repeat([]byte("F"), 15)},
+                {buf: bytes.Repeat([]byte("F"), 16)},
+                {buf: bytes.Repeat([]byte("F"), 17)},
+                {buf: bytes.Repeat([]byte("F"), 31)},
+                {buf: bytes.Repeat([]byte("F"), 32)},
+                {buf: bytes.Repeat([]byte("F"), 33)},
+                {buf: bytes.Repeat([]byte("F"), 1024)},
+                {buf: bytes.Repeat([]byte("F"), 1024*2)},
+                {buf: bytes.Repeat([]byte("F"), 1024*1024)},
+        }
+
+        const password = "correct horse battery staple" // https://xkcd.com/936/
+
+        for i, testCase := range testCases {
+                // Generate a random object name
+                objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+                args["objectName"] = objectName
+
+                // Secured object
+                sse := encrypt.DefaultPBKDF([]byte(password), []byte(bucketName+objectName))
+                args["sse"] = sse
+
+                // Put encrypted data
+                _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(testCase.buf), int64(len(testCase.buf)), minio.PutObjectOptions{ServerSideEncryption: sse})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutEncryptedObject failed", err)
+                        return
+                }
+
+                // Read the data back
+                r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{ServerSideEncryption: sse})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "GetEncryptedObject failed", err)
+                        return
+                }
+                defer r.Close()
+
+                // Compare the sent object with the received one
+                recvBuffer := bytes.NewBuffer([]byte{})
+                if _, err = io.Copy(recvBuffer, r); err != nil {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", error: "+err.Error(), err)
+                        return
+                }
+                if recvBuffer.Len() != len(testCase.buf) {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", Number of bytes of received object does not match, expected "+string(len(testCase.buf))+", got "+string(recvBuffer.Len()), err)
+                        return
+                }
+                if !bytes.Equal(testCase.buf, recvBuffer.Bytes()) {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", Encrypted sent is not equal to decrypted, expected "+string(testCase.buf)+", got "+string(recvBuffer.Bytes()), err)
+                        return
+                }
+
+                successLogger(testName, function, args, startTime).Info()
+
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// TestEncryptionFPut tests encryption with customer specified encryption keys
+func testSSECEncryptionFPut() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "FPutEncryptedObject(bucketName, objectName, filePath, contentType, sse)"
+        args := map[string]interface{}{
+                "bucketName":  "",
+                "objectName":  "",
+                "filePath":    "",
+                "contentType": "",
+                "sse":         "",
+        }
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Object custom metadata
+        customContentType := "custom/contenttype"
+        args["metadata"] = customContentType
+
+        testCases := []struct {
+                buf []byte
+        }{
+                {buf: bytes.Repeat([]byte("F"), 0)},
+                {buf: bytes.Repeat([]byte("F"), 1)},
+                {buf: bytes.Repeat([]byte("F"), 15)},
+                {buf: bytes.Repeat([]byte("F"), 16)},
+                {buf: bytes.Repeat([]byte("F"), 17)},
+                {buf: bytes.Repeat([]byte("F"), 31)},
+                {buf: bytes.Repeat([]byte("F"), 32)},
+                {buf: bytes.Repeat([]byte("F"), 33)},
+                {buf: bytes.Repeat([]byte("F"), 1024)},
+                {buf: bytes.Repeat([]byte("F"), 1024*2)},
+                {buf: bytes.Repeat([]byte("F"), 1024*1024)},
+        }
+
+        const password = "correct horse battery staple" // https://xkcd.com/936/
+        for i, testCase := range testCases {
+                // Generate a random object name
+                objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+                args["objectName"] = objectName
+
+                // Secured object
+                sse := encrypt.DefaultPBKDF([]byte(password), []byte(bucketName+objectName))
+                args["sse"] = sse
+
+                // Generate a random file name.
+                fileName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+                file, err := os.Create(fileName)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "file create failed", err)
+                        return
+                }
+                _, err = file.Write(testCase.buf)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "file write failed", err)
+                        return
+                }
+                file.Close()
+                // Put encrypted data
+                if _, err = c.FPutObject(context.Background(), bucketName, objectName, fileName, minio.PutObjectOptions{ServerSideEncryption: sse}); err != nil {
+                        logError(testName, function, args, startTime, "", "FPutEncryptedObject failed", err)
+                        return
+                }
+
+                // Read the data back
+                r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{ServerSideEncryption: sse})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "GetEncryptedObject failed", err)
+                        return
+                }
+                defer r.Close()
+
+                // Compare the sent object with the received one
+                recvBuffer := bytes.NewBuffer([]byte{})
+                if _, err = io.Copy(recvBuffer, r); err != nil {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", error: "+err.Error(), err)
+                        return
+                }
+                if recvBuffer.Len() != len(testCase.buf) {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", Number of bytes of received object does not match, expected "+string(len(testCase.buf))+", got "+string(recvBuffer.Len()), err)
+                        return
+                }
+                if !bytes.Equal(testCase.buf, recvBuffer.Bytes()) {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", Encrypted sent is not equal to decrypted, expected "+string(testCase.buf)+", got "+string(recvBuffer.Bytes()), err)
+                        return
+                }
+
+                os.Remove(fileName)
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// testSSES3EncryptionPutGet tests SSE-S3 encryption
+func testSSES3EncryptionPutGet() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutEncryptedObject(bucketName, objectName, reader, sse)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "sse":        "",
+        }
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        testCases := []struct {
+                buf []byte
+        }{
+                {buf: bytes.Repeat([]byte("F"), 1)},
+                {buf: bytes.Repeat([]byte("F"), 15)},
+                {buf: bytes.Repeat([]byte("F"), 16)},
+                {buf: bytes.Repeat([]byte("F"), 17)},
+                {buf: bytes.Repeat([]byte("F"), 31)},
+                {buf: bytes.Repeat([]byte("F"), 32)},
+                {buf: bytes.Repeat([]byte("F"), 33)},
+                {buf: bytes.Repeat([]byte("F"), 1024)},
+                {buf: bytes.Repeat([]byte("F"), 1024*2)},
+                {buf: bytes.Repeat([]byte("F"), 1024*1024)},
+        }
+
+        for i, testCase := range testCases {
+                // Generate a random object name
+                objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+                args["objectName"] = objectName
+
+                // Secured object
+                sse := encrypt.NewSSE()
+                args["sse"] = sse
+
+                // Put encrypted data
+                _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(testCase.buf), int64(len(testCase.buf)), minio.PutObjectOptions{ServerSideEncryption: sse})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutEncryptedObject failed", err)
+                        return
+                }
+
+                // Read the data back without any encryption headers
+                r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "GetEncryptedObject failed", err)
+                        return
+                }
+                defer r.Close()
+
+                // Compare the sent object with the received one
+                recvBuffer := bytes.NewBuffer([]byte{})
+                if _, err = io.Copy(recvBuffer, r); err != nil {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", error: "+err.Error(), err)
+                        return
+                }
+                if recvBuffer.Len() != len(testCase.buf) {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", Number of bytes of received object does not match, expected "+string(len(testCase.buf))+", got "+string(recvBuffer.Len()), err)
+                        return
+                }
+                if !bytes.Equal(testCase.buf, recvBuffer.Bytes()) {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", Encrypted sent is not equal to decrypted, expected "+string(testCase.buf)+", got "+string(recvBuffer.Bytes()), err)
+                        return
+                }
+
+                successLogger(testName, function, args, startTime).Info()
+
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// TestSSES3EncryptionFPut tests server side encryption
+func testSSES3EncryptionFPut() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "FPutEncryptedObject(bucketName, objectName, filePath, contentType, sse)"
+        args := map[string]interface{}{
+                "bucketName":  "",
+                "objectName":  "",
+                "filePath":    "",
+                "contentType": "",
+                "sse":         "",
+        }
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Object custom metadata
+        customContentType := "custom/contenttype"
+        args["metadata"] = customContentType
+
+        testCases := []struct {
+                buf []byte
+        }{
+                {buf: bytes.Repeat([]byte("F"), 0)},
+                {buf: bytes.Repeat([]byte("F"), 1)},
+                {buf: bytes.Repeat([]byte("F"), 15)},
+                {buf: bytes.Repeat([]byte("F"), 16)},
+                {buf: bytes.Repeat([]byte("F"), 17)},
+                {buf: bytes.Repeat([]byte("F"), 31)},
+                {buf: bytes.Repeat([]byte("F"), 32)},
+                {buf: bytes.Repeat([]byte("F"), 33)},
+                {buf: bytes.Repeat([]byte("F"), 1024)},
+                {buf: bytes.Repeat([]byte("F"), 1024*2)},
+                {buf: bytes.Repeat([]byte("F"), 1024*1024)},
+        }
+
+        for i, testCase := range testCases {
+                // Generate a random object name
+                objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+                args["objectName"] = objectName
+
+                // Secured object
+                sse := encrypt.NewSSE()
+                args["sse"] = sse
+
+                // Generate a random file name.
+                fileName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+                file, err := os.Create(fileName)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "file create failed", err)
+                        return
+                }
+                _, err = file.Write(testCase.buf)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "file write failed", err)
+                        return
+                }
+                file.Close()
+                // Put encrypted data
+                if _, err = c.FPutObject(context.Background(), bucketName, objectName, fileName, minio.PutObjectOptions{ServerSideEncryption: sse}); err != nil {
+                        logError(testName, function, args, startTime, "", "FPutEncryptedObject failed", err)
+                        return
+                }
+
+                // Read the data back
+                r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "GetEncryptedObject failed", err)
+                        return
+                }
+                defer r.Close()
+
+                // Compare the sent object with the received one
+                recvBuffer := bytes.NewBuffer([]byte{})
+                if _, err = io.Copy(recvBuffer, r); err != nil {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", error: "+err.Error(), err)
+                        return
+                }
+                if recvBuffer.Len() != len(testCase.buf) {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", Number of bytes of received object does not match, expected "+string(len(testCase.buf))+", got "+string(recvBuffer.Len()), err)
+                        return
+                }
+                if !bytes.Equal(testCase.buf, recvBuffer.Bytes()) {
+                        logError(testName, function, args, startTime, "", "Test "+string(i+1)+", Encrypted sent is not equal to decrypted, expected "+string(testCase.buf)+", got "+string(recvBuffer.Bytes()), err)
+                        return
+                }
+
+                os.Remove(fileName)
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testBucketNotification() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "SetBucketNotification(bucketName)"
+        args := map[string]interface{}{
+                "bucketName": "",
+        }
+
+        if os.Getenv("NOTIFY_BUCKET") == "" ||
+                os.Getenv("NOTIFY_SERVICE") == "" ||
+                os.Getenv("NOTIFY_REGION") == "" ||
+                os.Getenv("NOTIFY_ACCOUNTID") == "" ||
+                os.Getenv("NOTIFY_RESOURCE") == "" {
+                ignoredLog(testName, function, args, startTime, "Skipped notification test as it is not configured").Info()
+                return
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable to debug
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        bucketName := os.Getenv("NOTIFY_BUCKET")
+        args["bucketName"] = bucketName
+
+        topicArn := notification.NewArn("aws", os.Getenv("NOTIFY_SERVICE"), os.Getenv("NOTIFY_REGION"), os.Getenv("NOTIFY_ACCOUNTID"), os.Getenv("NOTIFY_RESOURCE"))
+        queueArn := notification.NewArn("aws", "dummy-service", "dummy-region", "dummy-accountid", "dummy-resource")
+
+        topicConfig := notification.NewConfig(topicArn)
+        topicConfig.AddEvents(notification.ObjectCreatedAll, notification.ObjectRemovedAll)
+        topicConfig.AddFilterSuffix("jpg")
+
+        queueConfig := notification.NewConfig(queueArn)
+        queueConfig.AddEvents(notification.ObjectCreatedAll)
+        queueConfig.AddFilterPrefix("photos/")
+
+        config := notification.Configuration{}
+        config.AddTopic(topicConfig)
+
+        // Add the same topicConfig again, should have no effect
+        // because it is duplicated
+        config.AddTopic(topicConfig)
+        if len(config.TopicConfigs) != 1 {
+                logError(testName, function, args, startTime, "", "Duplicate entry added", err)
+                return
+        }
+
+        // Add and remove a queue config
+        config.AddQueue(queueConfig)
+        config.RemoveQueueByArn(queueArn)
+
+        err = c.SetBucketNotification(context.Background(), bucketName, config)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "SetBucketNotification failed", err)
+                return
+        }
+
+        config, err = c.GetBucketNotification(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetBucketNotification failed", err)
+                return
+        }
+
+        if len(config.TopicConfigs) != 1 {
+                logError(testName, function, args, startTime, "", "Topic config is empty", err)
+                return
+        }
+
+        if config.TopicConfigs[0].Filter.S3Key.FilterRules[0].Value != "jpg" {
+                logError(testName, function, args, startTime, "", "Couldn't get the suffix", err)
+                return
+        }
+
+        err = c.RemoveAllBucketNotification(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "RemoveAllBucketNotification failed", err)
+                return
+        }
+
+        // Delete all objects and buckets
+        if err = cleanupBucket(bucketName, c); err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests comprehensive list of all methods.
+func testFunctional() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "testFunctional()"
+        functionAll := ""
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, nil, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable to debug
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        // Make a new bucket.
+        function = "MakeBucket(bucketName, region)"
+        functionAll = "MakeBucket(bucketName, region)"
+        args["bucketName"] = bucketName
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+
+        defer cleanupBucket(bucketName, c)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        // Generate a random file name.
+        fileName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        file, err := os.Create(fileName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "File creation failed", err)
+                return
+        }
+        for i := 0; i < 3; i++ {
+                buf := make([]byte, rand.Intn(1<<19))
+                _, err = file.Write(buf)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "File write failed", err)
+                        return
+                }
+        }
+        file.Close()
+
+        // Verify if bucket exits and you have access.
+        var exists bool
+        function = "BucketExists(bucketName)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+        }
+        exists, err = c.BucketExists(context.Background(), bucketName)
+
+        if err != nil {
+                logError(testName, function, args, startTime, "", "BucketExists failed", err)
+                return
+        }
+        if !exists {
+                logError(testName, function, args, startTime, "", "Could not find the bucket", err)
+                return
+        }
+
+        // Asserting the default bucket policy.
+        function = "GetBucketPolicy(ctx, bucketName)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+        }
+        nilPolicy, err := c.GetBucketPolicy(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetBucketPolicy failed", err)
+                return
+        }
+        if nilPolicy != "" {
+                logError(testName, function, args, startTime, "", "policy should be set to nil", err)
+                return
+        }
+
+        // Set the bucket policy to 'public readonly'.
+        function = "SetBucketPolicy(bucketName, readOnlyPolicy)"
+        functionAll += ", " + function
+
+        readOnlyPolicy := `{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"AWS":["*"]},"Action":["s3:ListBucket"],"Resource":["arn:aws:s3:::` + bucketName + `"]}]}`
+        args = map[string]interface{}{
+                "bucketName":   bucketName,
+                "bucketPolicy": readOnlyPolicy,
+        }
+
+        err = c.SetBucketPolicy(context.Background(), bucketName, readOnlyPolicy)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "SetBucketPolicy failed", err)
+                return
+        }
+        // should return policy `readonly`.
+        function = "GetBucketPolicy(ctx, bucketName)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+        }
+        _, err = c.GetBucketPolicy(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetBucketPolicy failed", err)
+                return
+        }
+
+        // Make the bucket 'public writeonly'.
+        function = "SetBucketPolicy(bucketName, writeOnlyPolicy)"
+        functionAll += ", " + function
+
+        writeOnlyPolicy := `{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"AWS":["*"]},"Action":["s3:ListBucketMultipartUploads"],"Resource":["arn:aws:s3:::` + bucketName + `"]}]}`
+        args = map[string]interface{}{
+                "bucketName":   bucketName,
+                "bucketPolicy": writeOnlyPolicy,
+        }
+        err = c.SetBucketPolicy(context.Background(), bucketName, writeOnlyPolicy)
+
+        if err != nil {
+                logError(testName, function, args, startTime, "", "SetBucketPolicy failed", err)
+                return
+        }
+        // should return policy `writeonly`.
+        function = "GetBucketPolicy(ctx, bucketName)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+        }
+
+        _, err = c.GetBucketPolicy(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetBucketPolicy failed", err)
+                return
+        }
+
+        // Make the bucket 'public read/write'.
+        function = "SetBucketPolicy(bucketName, readWritePolicy)"
+        functionAll += ", " + function
+
+        readWritePolicy := `{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"AWS":["*"]},"Action":["s3:ListBucket","s3:ListBucketMultipartUploads"],"Resource":["arn:aws:s3:::` + bucketName + `"]}]}`
+
+        args = map[string]interface{}{
+                "bucketName":   bucketName,
+                "bucketPolicy": readWritePolicy,
+        }
+        err = c.SetBucketPolicy(context.Background(), bucketName, readWritePolicy)
+
+        if err != nil {
+                logError(testName, function, args, startTime, "", "SetBucketPolicy failed", err)
+                return
+        }
+        // should return policy `readwrite`.
+        function = "GetBucketPolicy(bucketName)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+        }
+        _, err = c.GetBucketPolicy(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetBucketPolicy failed", err)
+                return
+        }
+
+        // List all buckets.
+        function = "ListBuckets()"
+        functionAll += ", " + function
+        args = nil
+        buckets, err := c.ListBuckets(context.Background())
+
+        if len(buckets) == 0 {
+                logError(testName, function, args, startTime, "", "Found bucket list to be empty", err)
+                return
+        }
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ListBuckets failed", err)
+                return
+        }
+
+        // Verify if previously created bucket is listed in list buckets.
+        bucketFound := false
+        for _, bucket := range buckets {
+                if bucket.Name == bucketName {
+                        bucketFound = true
+                }
+        }
+
+        // If bucket not found error out.
+        if !bucketFound {
+                logError(testName, function, args, startTime, "", "Bucket: "+bucketName+" not found", err)
+                return
+        }
+
+        objectName := bucketName + "unique"
+
+        // Generate data
+        buf := bytes.Repeat([]byte("f"), 1<<19)
+
+        function = "PutObject(bucketName, objectName, reader, contentType)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName":  bucketName,
+                "objectName":  objectName,
+                "contentType": "",
+        }
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        args = map[string]interface{}{
+                "bucketName":  bucketName,
+                "objectName":  objectName + "-nolength",
+                "contentType": "binary/octet-stream",
+        }
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName+"-nolength", bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Instantiate a done channel to close all listing.
+        doneCh := make(chan struct{})
+        defer close(doneCh)
+
+        objFound := false
+        isRecursive := true // Recursive is true.
+
+        function = "ListObjects(bucketName, objectName, isRecursive, doneCh)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName":  bucketName,
+                "objectName":  objectName,
+                "isRecursive": isRecursive,
+        }
+
+        for obj := range c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{UseV1: true, Prefix: objectName, Recursive: true}) {
+                if obj.Key == objectName {
+                        objFound = true
+                        break
+                }
+        }
+        if !objFound {
+                logError(testName, function, args, startTime, "", "Object "+objectName+" not found", err)
+                return
+        }
+
+        objFound = false
+        isRecursive = true // Recursive is true.
+        function = "ListObjects()"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName":  bucketName,
+                "objectName":  objectName,
+                "isRecursive": isRecursive,
+        }
+
+        for obj := range c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{Prefix: objectName, Recursive: isRecursive}) {
+                if obj.Key == objectName {
+                        objFound = true
+                        break
+                }
+        }
+        if !objFound {
+                logError(testName, function, args, startTime, "", "Object "+objectName+" not found", err)
+                return
+        }
+
+        incompObjNotFound := true
+
+        function = "ListIncompleteUploads(bucketName, objectName, isRecursive, doneCh)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName":  bucketName,
+                "objectName":  objectName,
+                "isRecursive": isRecursive,
+        }
+
+        for objIncompl := range c.ListIncompleteUploads(context.Background(), bucketName, objectName, isRecursive) {
+                if objIncompl.Key != "" {
+                        incompObjNotFound = false
+                        break
+                }
+        }
+        if !incompObjNotFound {
+                logError(testName, function, args, startTime, "", "Unexpected dangling incomplete upload found", err)
+                return
+        }
+
+        function = "GetObject(bucketName, objectName)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": objectName,
+        }
+        newReader, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+
+        newReadBytes, err := io.ReadAll(newReader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+
+        if !bytes.Equal(newReadBytes, buf) {
+                logError(testName, function, args, startTime, "", "GetObject bytes mismatch", err)
+                return
+        }
+        newReader.Close()
+
+        function = "FGetObject(bucketName, objectName, fileName)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": objectName,
+                "fileName":   fileName + "-f",
+        }
+        err = c.FGetObject(context.Background(), bucketName, objectName, fileName+"-f", minio.GetObjectOptions{})
+
+        if err != nil {
+                logError(testName, function, args, startTime, "", "FGetObject failed", err)
+                return
+        }
+
+        function = "PresignedHeadObject(bucketName, objectName, expires, reqParams)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": "",
+                "expires":    3600 * time.Second,
+        }
+        if _, err = c.PresignedHeadObject(context.Background(), bucketName, "", 3600*time.Second, nil); err == nil {
+                logError(testName, function, args, startTime, "", "PresignedHeadObject success", err)
+                return
+        }
+
+        // Generate presigned HEAD object url.
+        function = "PresignedHeadObject(bucketName, objectName, expires, reqParams)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": objectName,
+                "expires":    3600 * time.Second,
+        }
+        presignedHeadURL, err := c.PresignedHeadObject(context.Background(), bucketName, objectName, 3600*time.Second, nil)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedHeadObject failed", err)
+                return
+        }
+
+        transport, err := minio.DefaultTransport(mustParseBool(os.Getenv(enableHTTPS)))
+        if err != nil {
+                logError(testName, function, args, startTime, "", "DefaultTransport failed", err)
+                return
+        }
+
+        httpClient := &http.Client{
+                // Setting a sensible time out of 30secs to wait for response
+                // headers. Request is pro-actively canceled after 30secs
+                // with no response.
+                Timeout:   30 * time.Second,
+                Transport: transport,
+        }
+
+        req, err := http.NewRequest(http.MethodHead, presignedHeadURL.String(), nil)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedHeadObject request was incorrect", err)
+                return
+        }
+
+        // Verify if presigned url works.
+        resp, err := httpClient.Do(req)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedHeadObject response incorrect", err)
+                return
+        }
+        if resp.StatusCode != http.StatusOK {
+                logError(testName, function, args, startTime, "", "PresignedHeadObject response incorrect, status "+string(resp.StatusCode), err)
+                return
+        }
+        if resp.Header.Get("ETag") == "" {
+                logError(testName, function, args, startTime, "", "PresignedHeadObject response incorrect", err)
+                return
+        }
+        resp.Body.Close()
+
+        function = "PresignedGetObject(bucketName, objectName, expires, reqParams)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": "",
+                "expires":    3600 * time.Second,
+        }
+        _, err = c.PresignedGetObject(context.Background(), bucketName, "", 3600*time.Second, nil)
+        if err == nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject success", err)
+                return
+        }
+
+        // Generate presigned GET object url.
+        function = "PresignedGetObject(bucketName, objectName, expires, reqParams)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": objectName,
+                "expires":    3600 * time.Second,
+        }
+        presignedGetURL, err := c.PresignedGetObject(context.Background(), bucketName, objectName, 3600*time.Second, nil)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject failed", err)
+                return
+        }
+
+        // Verify if presigned url works.
+        req, err = http.NewRequest(http.MethodGet, presignedGetURL.String(), nil)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject request incorrect", err)
+                return
+        }
+
+        resp, err = httpClient.Do(req)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject response incorrect", err)
+                return
+        }
+        if resp.StatusCode != http.StatusOK {
+                logError(testName, function, args, startTime, "", "PresignedGetObject response incorrect, status "+string(resp.StatusCode), err)
+                return
+        }
+        newPresignedBytes, err := io.ReadAll(resp.Body)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject response incorrect", err)
+                return
+        }
+        resp.Body.Close()
+        if !bytes.Equal(newPresignedBytes, buf) {
+                logError(testName, function, args, startTime, "", "PresignedGetObject response incorrect", err)
+                return
+        }
+
+        // Set request parameters.
+        reqParams := make(url.Values)
+        reqParams.Set("response-content-disposition", "attachment; filename=\"test.txt\"")
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": objectName,
+                "expires":    3600 * time.Second,
+                "reqParams":  reqParams,
+        }
+        presignedGetURL, err = c.PresignedGetObject(context.Background(), bucketName, objectName, 3600*time.Second, reqParams)
+
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject failed", err)
+                return
+        }
+
+        // Verify if presigned url works.
+        req, err = http.NewRequest(http.MethodGet, presignedGetURL.String(), nil)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject request incorrect", err)
+                return
+        }
+
+        resp, err = httpClient.Do(req)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject response incorrect", err)
+                return
+        }
+        if resp.StatusCode != http.StatusOK {
+                logError(testName, function, args, startTime, "", "PresignedGetObject response incorrect, status "+string(resp.StatusCode), err)
+                return
+        }
+        newPresignedBytes, err = io.ReadAll(resp.Body)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject response incorrect", err)
+                return
+        }
+        if !bytes.Equal(newPresignedBytes, buf) {
+                logError(testName, function, args, startTime, "", "Bytes mismatch for presigned GET URL", err)
+                return
+        }
+        if resp.Header.Get("Content-Disposition") != "attachment; filename=\"test.txt\"" {
+                logError(testName, function, args, startTime, "", "wrong Content-Disposition received "+string(resp.Header.Get("Content-Disposition")), err)
+                return
+        }
+
+        function = "PresignedPutObject(bucketName, objectName, expires)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": "",
+                "expires":    3600 * time.Second,
+        }
+        _, err = c.PresignedPutObject(context.Background(), bucketName, "", 3600*time.Second)
+        if err == nil {
+                logError(testName, function, args, startTime, "", "PresignedPutObject success", err)
+                return
+        }
+
+        function = "PresignedPutObject(bucketName, objectName, expires)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": objectName + "-presigned",
+                "expires":    3600 * time.Second,
+        }
+        presignedPutURL, err := c.PresignedPutObject(context.Background(), bucketName, objectName+"-presigned", 3600*time.Second)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedPutObject failed", err)
+                return
+        }
+
+        buf = bytes.Repeat([]byte("g"), 1<<19)
+
+        req, err = http.NewRequest(http.MethodPut, presignedPutURL.String(), bytes.NewReader(buf))
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Couldn't make HTTP request with PresignedPutObject URL", err)
+                return
+        }
+
+        resp, err = httpClient.Do(req)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedPutObject failed", err)
+                return
+        }
+
+        newReader, err = c.GetObject(context.Background(), bucketName, objectName+"-presigned", minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject after PresignedPutObject failed", err)
+                return
+        }
+
+        newReadBytes, err = io.ReadAll(newReader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll after GetObject failed", err)
+                return
+        }
+
+        if !bytes.Equal(newReadBytes, buf) {
+                logError(testName, function, args, startTime, "", "Bytes mismatch", err)
+                return
+        }
+
+        function = "PresignHeader(method, bucketName, objectName, expires, reqParams, extraHeaders)"
+        functionAll += ", " + function
+        presignExtraHeaders := map[string][]string{
+                "mysecret": {"abcxxx"},
+        }
+        args = map[string]interface{}{
+                "method":       "PUT",
+                "bucketName":   bucketName,
+                "objectName":   objectName + "-presign-custom",
+                "expires":      3600 * time.Second,
+                "extraHeaders": presignExtraHeaders,
+        }
+        presignedURL, err := c.PresignHeader(context.Background(), "PUT", bucketName, objectName+"-presign-custom", 3600*time.Second, nil, presignExtraHeaders)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Presigned failed", err)
+                return
+        }
+
+        // Generate data more than 32K
+        buf = bytes.Repeat([]byte("1"), rand.Intn(1<<10)+32*1024)
+
+        req, err = http.NewRequest(http.MethodPut, presignedURL.String(), bytes.NewReader(buf))
+        if err != nil {
+                logError(testName, function, args, startTime, "", "HTTP request to Presigned URL failed", err)
+                return
+        }
+
+        req.Header.Add("mysecret", "abcxxx")
+        resp, err = httpClient.Do(req)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "HTTP request to Presigned URL failed", err)
+                return
+        }
+
+        // Download the uploaded object to verify
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": objectName + "-presign-custom",
+        }
+        newReader, err = c.GetObject(context.Background(), bucketName, objectName+"-presign-custom", minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject of uploaded custom-presigned object failed", err)
+                return
+        }
+
+        newReadBytes, err = io.ReadAll(newReader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed during get on custom-presigned put object", err)
+                return
+        }
+        newReader.Close()
+
+        if !bytes.Equal(newReadBytes, buf) {
+                logError(testName, function, args, startTime, "", "Bytes mismatch on custom-presigned object upload verification", err)
+                return
+        }
+
+        function = "RemoveObject(bucketName, objectName)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": objectName,
+        }
+        err = c.RemoveObject(context.Background(), bucketName, objectName, minio.RemoveObjectOptions{})
+
+        if err != nil {
+                logError(testName, function, args, startTime, "", "RemoveObject failed", err)
+                return
+        }
+        args["objectName"] = objectName + "-f"
+        err = c.RemoveObject(context.Background(), bucketName, objectName+"-f", minio.RemoveObjectOptions{})
+
+        if err != nil {
+                logError(testName, function, args, startTime, "", "RemoveObject failed", err)
+                return
+        }
+
+        args["objectName"] = objectName + "-nolength"
+        err = c.RemoveObject(context.Background(), bucketName, objectName+"-nolength", minio.RemoveObjectOptions{})
+
+        if err != nil {
+                logError(testName, function, args, startTime, "", "RemoveObject failed", err)
+                return
+        }
+
+        args["objectName"] = objectName + "-presigned"
+        err = c.RemoveObject(context.Background(), bucketName, objectName+"-presigned", minio.RemoveObjectOptions{})
+
+        if err != nil {
+                logError(testName, function, args, startTime, "", "RemoveObject failed", err)
+                return
+        }
+
+        args["objectName"] = objectName + "-presign-custom"
+        err = c.RemoveObject(context.Background(), bucketName, objectName+"-presign-custom", minio.RemoveObjectOptions{})
+
+        if err != nil {
+                logError(testName, function, args, startTime, "", "RemoveObject failed", err)
+                return
+        }
+
+        function = "RemoveBucket(bucketName)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+        }
+        err = c.RemoveBucket(context.Background(), bucketName)
+
+        if err != nil {
+                logError(testName, function, args, startTime, "", "RemoveBucket failed", err)
+                return
+        }
+        err = c.RemoveBucket(context.Background(), bucketName)
+        if err == nil {
+                logError(testName, function, args, startTime, "", "RemoveBucket did not fail for invalid bucket name", err)
+                return
+        }
+        if err.Error() != "The specified bucket does not exist" {
+                logError(testName, function, args, startTime, "", "RemoveBucket failed", err)
+                return
+        }
+
+        os.Remove(fileName)
+        os.Remove(fileName + "-f")
+        successLogger(testName, functionAll, args, startTime).Info()
+}
+
+// Test for validating GetObject Reader* methods functioning when the
+// object is modified in the object store.
+func testGetObjectModified() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(bucketName, objectName)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Make a new bucket.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Upload an object.
+        objectName := "myobject"
+        args["objectName"] = objectName
+        content := "helloworld"
+        _, err = c.PutObject(context.Background(), bucketName, objectName, strings.NewReader(content), int64(len(content)), minio.PutObjectOptions{ContentType: "application/text"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Failed to upload "+objectName+", to bucket "+bucketName, err)
+                return
+        }
+
+        defer c.RemoveObject(context.Background(), bucketName, objectName, minio.RemoveObjectOptions{})
+
+        reader, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Failed to GetObject "+objectName+", from bucket "+bucketName, err)
+                return
+        }
+        defer reader.Close()
+
+        // Read a few bytes of the object.
+        b := make([]byte, 5)
+        n, err := reader.ReadAt(b, 0)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Failed to read object "+objectName+", from bucket "+bucketName+" at an offset", err)
+                return
+        }
+
+        // Upload different contents to the same object while object is being read.
+        newContent := "goodbyeworld"
+        _, err = c.PutObject(context.Background(), bucketName, objectName, strings.NewReader(newContent), int64(len(newContent)), minio.PutObjectOptions{ContentType: "application/text"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Failed to upload "+objectName+", to bucket "+bucketName, err)
+                return
+        }
+
+        // Confirm that a Stat() call in between doesn't change the Object's cached etag.
+        _, err = reader.Stat()
+        expectedError := "At least one of the pre-conditions you specified did not hold"
+        if err.Error() != expectedError {
+                logError(testName, function, args, startTime, "", "Expected Stat to fail with error "+expectedError+", but received "+err.Error(), err)
+                return
+        }
+
+        // Read again only to find object contents have been modified since last read.
+        _, err = reader.ReadAt(b, int64(n))
+        if err.Error() != expectedError {
+                logError(testName, function, args, startTime, "", "Expected ReadAt to fail with error "+expectedError+", but received "+err.Error(), err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test validates putObject to upload a file seeked at a given offset.
+func testPutObjectUploadSeekedObject() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(bucketName, objectName, fileToUpload, contentType)"
+        args := map[string]interface{}{
+                "bucketName":   "",
+                "objectName":   "",
+                "fileToUpload": "",
+                "contentType":  "binary/octet-stream",
+        }
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Make a new bucket.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName, c)
+
+        var tempfile *os.File
+
+        if fileName := getMintDataDirFilePath("datafile-100-kB"); fileName != "" {
+                tempfile, err = os.Open(fileName)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "File open failed", err)
+                        return
+                }
+                args["fileToUpload"] = fileName
+        } else {
+                tempfile, err = os.CreateTemp("", "minio-go-upload-test-")
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "TempFile create failed", err)
+                        return
+                }
+                args["fileToUpload"] = tempfile.Name()
+
+                // Generate 100kB data
+                if _, err = io.Copy(tempfile, getDataReader("datafile-100-kB")); err != nil {
+                        logError(testName, function, args, startTime, "", "File copy failed", err)
+                        return
+                }
+
+                defer os.Remove(tempfile.Name())
+
+                // Seek back to the beginning of the file.
+                tempfile.Seek(0, 0)
+        }
+        length := 100 * humanize.KiByte
+        objectName := fmt.Sprintf("test-file-%v", rand.Uint32())
+        args["objectName"] = objectName
+
+        offset := length / 2
+        if _, err = tempfile.Seek(int64(offset), 0); err != nil {
+                logError(testName, function, args, startTime, "", "TempFile seek failed", err)
+                return
+        }
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, tempfile, int64(length-offset), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+        tempfile.Close()
+
+        obj, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+        defer obj.Close()
+
+        n, err := obj.Seek(int64(offset), 0)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Seek failed", err)
+                return
+        }
+        if n != int64(offset) {
+                logError(testName, function, args, startTime, "", fmt.Sprintf("Invalid offset returned, expected %d got %d", int64(offset), n), err)
+                return
+        }
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName+"getobject", obj, int64(length-offset), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+        st, err := c.StatObject(context.Background(), bucketName, objectName+"getobject", minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+        if st.Size != int64(length-offset) {
+                logError(testName, function, args, startTime, "", fmt.Sprintf("Invalid offset returned, expected %d got %d", int64(length-offset), n), err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests bucket re-create errors.
+func testMakeBucketErrorV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "MakeBucket(bucketName, region)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "region":     "eu-west-1",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        region := "eu-west-1"
+        args["bucketName"] = bucketName
+        args["region"] = region
+
+        // Make a new bucket in 'eu-west-1'.
+        if err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: region}); err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        if err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: region}); err == nil {
+                logError(testName, function, args, startTime, "", "MakeBucket did not fail for existing bucket name", err)
+                return
+        }
+        // Verify valid error response from server.
+        if minio.ToErrorResponse(err).Code != "BucketAlreadyExists" &&
+                minio.ToErrorResponse(err).Code != "BucketAlreadyOwnedByYou" {
+                logError(testName, function, args, startTime, "", "Invalid error returned by server", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test get object reader to not throw error on being closed twice.
+func testGetObjectClosedTwiceV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "MakeBucket(bucketName, region)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "region":     "eu-west-1",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Generate 33K of data.
+        bufSize := dataFileMap["datafile-33-kB"]
+        reader := getDataReader("datafile-33-kB")
+        defer reader.Close()
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes does not match, expected "+string(bufSize)+" got "+string(st.Size), err)
+                return
+        }
+        if err := r.Close(); err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+        if err := r.Close(); err == nil {
+                logError(testName, function, args, startTime, "", "Object is already closed, should return error", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests FPutObject hidden contentType setting
+func testFPutObjectV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "FPutObject(bucketName, objectName, fileName, opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "fileName":   "",
+                "opts":       "",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Make a temp file with 11*1024*1024 bytes of data.
+        file, err := os.CreateTemp(os.TempDir(), "FPutObjectTest")
+        if err != nil {
+                logError(testName, function, args, startTime, "", "TempFile creation failed", err)
+                return
+        }
+
+        r := bytes.NewReader(bytes.Repeat([]byte("b"), 11*1024*1024))
+        n, err := io.CopyN(file, r, 11*1024*1024)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Copy failed", err)
+                return
+        }
+        if n != int64(11*1024*1024) {
+                logError(testName, function, args, startTime, "", "Number of bytes does not match, expected "+string(int64(11*1024*1024))+" got "+string(n), err)
+                return
+        }
+
+        // Close the file pro-actively for windows.
+        err = file.Close()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "File close failed", err)
+                return
+        }
+
+        // Set base object name
+        objectName := bucketName + "FPutObject"
+        args["objectName"] = objectName
+        args["fileName"] = file.Name()
+
+        // Perform standard FPutObject with contentType provided (Expecting application/octet-stream)
+        _, err = c.FPutObject(context.Background(), bucketName, objectName+"-standard", file.Name(), minio.PutObjectOptions{ContentType: "application/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "FPutObject failed", err)
+                return
+        }
+
+        // Perform FPutObject with no contentType provided (Expecting application/octet-stream)
+        args["objectName"] = objectName + "-Octet"
+        args["contentType"] = ""
+
+        _, err = c.FPutObject(context.Background(), bucketName, objectName+"-Octet", file.Name(), minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "FPutObject failed", err)
+                return
+        }
+
+        // Add extension to temp file name
+        fileName := file.Name()
+        err = os.Rename(fileName, fileName+".gtar")
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Rename failed", err)
+                return
+        }
+
+        // Perform FPutObject with no contentType provided (Expecting application/x-gtar)
+        args["objectName"] = objectName + "-Octet"
+        args["contentType"] = ""
+        args["fileName"] = fileName + ".gtar"
+
+        _, err = c.FPutObject(context.Background(), bucketName, objectName+"-GTar", fileName+".gtar", minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "FPutObject failed", err)
+                return
+        }
+
+        // Check headers and sizes
+        rStandard, err := c.StatObject(context.Background(), bucketName, objectName+"-standard", minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+
+        if rStandard.Size != 11*1024*1024 {
+                logError(testName, function, args, startTime, "", "Unexpected size", nil)
+                return
+        }
+
+        if rStandard.ContentType != "application/octet-stream" {
+                logError(testName, function, args, startTime, "", "Content-Type headers mismatched, expected: application/octet-stream , got "+rStandard.ContentType, err)
+                return
+        }
+
+        rOctet, err := c.StatObject(context.Background(), bucketName, objectName+"-Octet", minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+        if rOctet.ContentType != "application/octet-stream" {
+                logError(testName, function, args, startTime, "", "Content-Type headers mismatched, expected: application/octet-stream , got "+rOctet.ContentType, err)
+                return
+        }
+
+        if rOctet.Size != 11*1024*1024 {
+                logError(testName, function, args, startTime, "", "Unexpected size", nil)
+                return
+        }
+
+        rGTar, err := c.StatObject(context.Background(), bucketName, objectName+"-GTar", minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+        if rGTar.Size != 11*1024*1024 {
+                logError(testName, function, args, startTime, "", "Unexpected size", nil)
+                return
+        }
+        if rGTar.ContentType != "application/x-gtar" && rGTar.ContentType != "application/octet-stream" && rGTar.ContentType != "application/x-tar" {
+                logError(testName, function, args, startTime, "", "Content-Type headers mismatched, expected: application/x-tar , got "+rGTar.ContentType, err)
+                return
+        }
+
+        os.Remove(fileName + ".gtar")
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests various bucket supported formats.
+func testMakeBucketRegionsV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "MakeBucket(bucketName, region)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "region":     "eu-west-1",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket in 'eu-central-1'.
+        if err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "eu-west-1"}); err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        if err = cleanupBucket(bucketName, c); err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed while removing bucket recursively", err)
+                return
+        }
+
+        // Make a new bucket with '.' in its name, in 'us-west-2'. This
+        // request is internally staged into a path style instead of
+        // virtual host style.
+        if err = c.MakeBucket(context.Background(), bucketName+".withperiod", minio.MakeBucketOptions{Region: "us-west-2"}); err != nil {
+                args["bucketName"] = bucketName + ".withperiod"
+                args["region"] = "us-west-2"
+                logError(testName, function, args, startTime, "", "MakeBucket test with a bucket name with period, '.', failed", err)
+                return
+        }
+
+        // Delete all objects and buckets
+        if err = cleanupBucket(bucketName+".withperiod", c); err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed while removing bucket recursively", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests get object ReaderSeeker interface methods.
+func testGetObjectReadSeekFunctionalV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(bucketName, objectName)"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Generate 33K of data.
+        bufSize := dataFileMap["datafile-33-kB"]
+        reader := getDataReader("datafile-33-kB")
+        defer reader.Close()
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        buf, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+
+        // Save the data.
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+        defer r.Close()
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes in stat does not match, expected "+string(int64(bufSize))+" got "+string(st.Size), err)
+                return
+        }
+
+        offset := int64(2048)
+        n, err := r.Seek(offset, 0)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Seek failed", err)
+                return
+        }
+        if n != offset {
+                logError(testName, function, args, startTime, "", "Number of seeked bytes does not match, expected "+string(offset)+" got "+string(n), err)
+                return
+        }
+        n, err = r.Seek(0, 1)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Seek failed", err)
+                return
+        }
+        if n != offset {
+                logError(testName, function, args, startTime, "", "Number of seeked bytes does not match, expected "+string(offset)+" got "+string(n), err)
+                return
+        }
+        _, err = r.Seek(offset, 2)
+        if err == nil {
+                logError(testName, function, args, startTime, "", "Seek on positive offset for whence '2' should error out", err)
+                return
+        }
+        n, err = r.Seek(-offset, 2)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Seek failed", err)
+                return
+        }
+        if n != st.Size-offset {
+                logError(testName, function, args, startTime, "", "Number of seeked bytes does not match, expected "+string(st.Size-offset)+" got "+string(n), err)
+                return
+        }
+
+        var buffer1 bytes.Buffer
+        if _, err = io.CopyN(&buffer1, r, st.Size); err != nil {
+                if err != io.EOF {
+                        logError(testName, function, args, startTime, "", "Copy failed", err)
+                        return
+                }
+        }
+        if !bytes.Equal(buf[len(buf)-int(offset):], buffer1.Bytes()) {
+                logError(testName, function, args, startTime, "", "Incorrect read bytes v/s original buffer", err)
+                return
+        }
+
+        // Seek again and read again.
+        n, err = r.Seek(offset-1, 0)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Seek failed", err)
+                return
+        }
+        if n != (offset - 1) {
+                logError(testName, function, args, startTime, "", "Number of seeked bytes does not match, expected "+string(offset-1)+" got "+string(n), err)
+                return
+        }
+
+        var buffer2 bytes.Buffer
+        if _, err = io.CopyN(&buffer2, r, st.Size); err != nil {
+                if err != io.EOF {
+                        logError(testName, function, args, startTime, "", "Copy failed", err)
+                        return
+                }
+        }
+        // Verify now lesser bytes.
+        if !bytes.Equal(buf[2047:], buffer2.Bytes()) {
+                logError(testName, function, args, startTime, "", "Incorrect read bytes v/s original buffer", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests get object ReaderAt interface methods.
+func testGetObjectReadAtFunctionalV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(bucketName, objectName)"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Generate 33K of data.
+        bufSize := dataFileMap["datafile-33-kB"]
+        reader := getDataReader("datafile-33-kB")
+        defer reader.Close()
+
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        buf, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+
+        // Save the data
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Read the data back
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+        defer r.Close()
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes does not match, expected "+string(bufSize)+" got "+string(st.Size), err)
+                return
+        }
+
+        offset := int64(2048)
+
+        // Read directly
+        buf2 := make([]byte, 512)
+        buf3 := make([]byte, 512)
+        buf4 := make([]byte, 512)
+
+        m, err := r.ReadAt(buf2, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf2) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf2))+" got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf2, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+        offset += 512
+        m, err = r.ReadAt(buf3, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf3) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf3))+" got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf3, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+        offset += 512
+        m, err = r.ReadAt(buf4, offset)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                return
+        }
+        if m != len(buf4) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf4))+" got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf4, buf[offset:offset+512]) {
+                logError(testName, function, args, startTime, "", "Incorrect read between two ReadAt from same offset", err)
+                return
+        }
+
+        buf5 := make([]byte, bufSize)
+        // Read the whole object.
+        m, err = r.ReadAt(buf5, 0)
+        if err != nil {
+                if err != io.EOF {
+                        logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                        return
+                }
+        }
+        if m != len(buf5) {
+                logError(testName, function, args, startTime, "", "ReadAt read shorter bytes before reaching EOF, expected "+string(len(buf5))+" got "+string(m), err)
+                return
+        }
+        if !bytes.Equal(buf, buf5) {
+                logError(testName, function, args, startTime, "", "Incorrect data read in GetObject, than what was previously uploaded", err)
+                return
+        }
+
+        buf6 := make([]byte, bufSize+1)
+        // Read the whole object and beyond.
+        _, err = r.ReadAt(buf6, 0)
+        if err != nil {
+                if err != io.EOF {
+                        logError(testName, function, args, startTime, "", "ReadAt failed", err)
+                        return
+                }
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Tests copy object
+func testCopyObjectV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        // Make a new bucket in 'us-east-1' (source bucket).
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName, c)
+
+        // Make a new bucket in 'us-east-1' (destination bucket).
+        err = c.MakeBucket(context.Background(), bucketName+"-copy", minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName+"-copy", c)
+
+        // Generate 33K of data.
+        bufSize := dataFileMap["datafile-33-kB"]
+        reader := getDataReader("datafile-33-kB")
+        defer reader.Close()
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        r, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+        // Check the various fields of source object against destination object.
+        objInfo, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+        r.Close()
+
+        // Copy Source
+        src := minio.CopySrcOptions{
+                Bucket:             bucketName,
+                Object:             objectName,
+                MatchModifiedSince: time.Date(2014, time.April, 0, 0, 0, 0, 0, time.UTC),
+                MatchETag:          objInfo.ETag,
+        }
+        args["source"] = src
+
+        // Set copy conditions.
+        dst := minio.CopyDestOptions{
+                Bucket: bucketName + "-copy",
+                Object: objectName + "-copy",
+        }
+        args["destination"] = dst
+
+        // Perform the Copy
+        _, err = c.CopyObject(context.Background(), dst, src)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObject failed", err)
+                return
+        }
+
+        // Source object
+        r, err = c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+        // Destination object
+        readerCopy, err := c.GetObject(context.Background(), bucketName+"-copy", objectName+"-copy", minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+        // Check the various fields of source object against destination object.
+        objInfo, err = r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+        objInfoCopy, err := readerCopy.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Stat failed", err)
+                return
+        }
+        if objInfo.Size != objInfoCopy.Size {
+                logError(testName, function, args, startTime, "", "Number of bytes does not match, expected "+string(objInfoCopy.Size)+" got "+string(objInfo.Size), err)
+                return
+        }
+
+        // Close all the readers.
+        r.Close()
+        readerCopy.Close()
+
+        // CopyObject again but with wrong conditions
+        src = minio.CopySrcOptions{
+                Bucket:               bucketName,
+                Object:               objectName,
+                MatchUnmodifiedSince: time.Date(2014, time.April, 0, 0, 0, 0, 0, time.UTC),
+                NoMatchETag:          objInfo.ETag,
+        }
+
+        // Perform the Copy which should fail
+        _, err = c.CopyObject(context.Background(), dst, src)
+        if err == nil {
+                logError(testName, function, args, startTime, "", "CopyObject did not fail for invalid conditions", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testComposeObjectErrorCasesWrapper(c *minio.Client) {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "ComposeObject(destination, sourceList)"
+        args := map[string]interface{}{}
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        // Make a new bucket in 'us-east-1' (source bucket).
+        err := c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Test that more than 10K source objects cannot be
+        // concatenated.
+        srcArr := [10001]minio.CopySrcOptions{}
+        srcSlice := srcArr[:]
+        dst := minio.CopyDestOptions{
+                Bucket: bucketName,
+                Object: "object",
+        }
+
+        args["destination"] = dst
+        // Just explain about srcArr in args["sourceList"]
+        // to stop having 10,001 null headers logged
+        args["sourceList"] = "source array of 10,001 elements"
+        if _, err := c.ComposeObject(context.Background(), dst, srcSlice...); err == nil {
+                logError(testName, function, args, startTime, "", "Expected error in ComposeObject", err)
+                return
+        } else if err.Error() != "There must be as least one and up to 10000 source objects." {
+                logError(testName, function, args, startTime, "", "Got unexpected error", err)
+                return
+        }
+
+        // Create a source with invalid offset spec and check that
+        // error is returned:
+        // 1. Create the source object.
+        const badSrcSize = 5 * 1024 * 1024
+        buf := bytes.Repeat([]byte("1"), badSrcSize)
+        _, err = c.PutObject(context.Background(), bucketName, "badObject", bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+        // 2. Set invalid range spec on the object (going beyond
+        // object size)
+        badSrc := minio.CopySrcOptions{
+                Bucket:     bucketName,
+                Object:     "badObject",
+                MatchRange: true,
+                Start:      1,
+                End:        badSrcSize,
+        }
+
+        // 3. ComposeObject call should fail.
+        if _, err := c.ComposeObject(context.Background(), dst, badSrc); err == nil {
+                logError(testName, function, args, startTime, "", "ComposeObject expected to fail", err)
+                return
+        } else if !strings.Contains(err.Error(), "has invalid segment-to-copy") {
+                logError(testName, function, args, startTime, "", "Got invalid error", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test expected error cases
+func testComposeObjectErrorCasesV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "ComposeObject(destination, sourceList)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+
+        testComposeObjectErrorCasesWrapper(c)
+}
+
+func testComposeMultipleSources(c *minio.Client) {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "ComposeObject(destination, sourceList)"
+        args := map[string]interface{}{
+                "destination": "",
+                "sourceList":  "",
+        }
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        // Make a new bucket in 'us-east-1' (source bucket).
+        err := c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Upload a small source object
+        const srcSize = 1024 * 1024 * 5
+        buf := bytes.Repeat([]byte("1"), srcSize)
+        _, err = c.PutObject(context.Background(), bucketName, "srcObject", bytes.NewReader(buf), int64(srcSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // We will append 10 copies of the object.
+        srcs := []minio.CopySrcOptions{}
+        for i := 0; i < 10; i++ {
+                srcs = append(srcs, minio.CopySrcOptions{
+                        Bucket: bucketName,
+                        Object: "srcObject",
+                })
+        }
+
+        // make the last part very small
+        srcs[9].MatchRange = true
+
+        args["sourceList"] = srcs
+
+        dst := minio.CopyDestOptions{
+                Bucket: bucketName,
+                Object: "dstObject",
+        }
+        args["destination"] = dst
+
+        ui, err := c.ComposeObject(context.Background(), dst, srcs...)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ComposeObject failed", err)
+                return
+        }
+
+        if ui.Size != 9*srcSize+1 {
+                logError(testName, function, args, startTime, "", "ComposeObject returned unexpected size", err)
+                return
+        }
+
+        objProps, err := c.StatObject(context.Background(), bucketName, "dstObject", minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+
+        if objProps.Size != 9*srcSize+1 {
+                logError(testName, function, args, startTime, "", "Size mismatched! Expected "+string(10000*srcSize)+" got "+string(objProps.Size), err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test concatenating multiple 10K objects V2
+func testCompose10KSourcesV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "ComposeObject(destination, sourceList)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+
+        testComposeMultipleSources(c)
+}
+
+func testEncryptedEmptyObject() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(bucketName, objectName, reader, objectSize, opts)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err)
+                return
+        }
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+        // Make a new bucket in 'us-east-1' (source bucket).
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        sse := encrypt.DefaultPBKDF([]byte("correct horse battery staple"), []byte(bucketName+"object"))
+
+        // 1. create an sse-c encrypted object to copy by uploading
+        const srcSize = 0
+        var buf []byte // Empty buffer
+        args["objectName"] = "object"
+        _, err = c.PutObject(context.Background(), bucketName, "object", bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{ServerSideEncryption: sse})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject call failed", err)
+                return
+        }
+
+        // 2. Test CopyObject for an empty object
+        src := minio.CopySrcOptions{
+                Bucket:     bucketName,
+                Object:     "object",
+                Encryption: sse,
+        }
+
+        dst := minio.CopyDestOptions{
+                Bucket:     bucketName,
+                Object:     "new-object",
+                Encryption: sse,
+        }
+
+        if _, err = c.CopyObject(context.Background(), dst, src); err != nil {
+                function = "CopyObject(dst, src)"
+                logError(testName, function, map[string]interface{}{}, startTime, "", "CopyObject failed", err)
+                return
+        }
+
+        // 3. Test Key rotation
+        newSSE := encrypt.DefaultPBKDF([]byte("Don't Panic"), []byte(bucketName+"new-object"))
+        src = minio.CopySrcOptions{
+                Bucket:     bucketName,
+                Object:     "new-object",
+                Encryption: sse,
+        }
+
+        dst = minio.CopyDestOptions{
+                Bucket:     bucketName,
+                Object:     "new-object",
+                Encryption: newSSE,
+        }
+
+        if _, err = c.CopyObject(context.Background(), dst, src); err != nil {
+                function = "CopyObject(dst, src)"
+                logError(testName, function, map[string]interface{}{}, startTime, "", "CopyObject with key rotation failed", err)
+                return
+        }
+
+        // 4. Download the object.
+        reader, err := c.GetObject(context.Background(), bucketName, "new-object", minio.GetObjectOptions{ServerSideEncryption: newSSE})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+        defer reader.Close()
+
+        decBytes, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, map[string]interface{}{}, startTime, "", "ReadAll failed", err)
+                return
+        }
+        if !bytes.Equal(decBytes, buf) {
+                logError(testName, function, map[string]interface{}{}, startTime, "", "Downloaded object doesn't match the empty encrypted object", err)
+                return
+        }
+
+        delete(args, "objectName")
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testEncryptedCopyObjectWrapper(c *minio.Client, bucketName string, sseSrc, sseDst encrypt.ServerSide) {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncNameLoc(2)
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+        var srcEncryption, dstEncryption encrypt.ServerSide
+
+        // Make a new bucket in 'us-east-1' (source bucket).
+        err := c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // 1. create an sse-c encrypted object to copy by uploading
+        const srcSize = 1024 * 1024
+        buf := bytes.Repeat([]byte("abcde"), srcSize) // gives a buffer of 5MiB
+        _, err = c.PutObject(context.Background(), bucketName, "srcObject", bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{
+                ServerSideEncryption: sseSrc,
+        })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject call failed", err)
+                return
+        }
+
+        if sseSrc != nil && sseSrc.Type() != encrypt.S3 {
+                srcEncryption = sseSrc
+        }
+
+        // 2. copy object and change encryption key
+        src := minio.CopySrcOptions{
+                Bucket:     bucketName,
+                Object:     "srcObject",
+                Encryption: srcEncryption,
+        }
+        args["source"] = src
+
+        dst := minio.CopyDestOptions{
+                Bucket:     bucketName,
+                Object:     "dstObject",
+                Encryption: sseDst,
+        }
+        args["destination"] = dst
+
+        _, err = c.CopyObject(context.Background(), dst, src)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObject failed", err)
+                return
+        }
+
+        if sseDst != nil && sseDst.Type() != encrypt.S3 {
+                dstEncryption = sseDst
+        }
+        // 3. get copied object and check if content is equal
+        coreClient := minio.Core{c}
+        reader, _, _, err := coreClient.GetObject(context.Background(), bucketName, "dstObject", minio.GetObjectOptions{ServerSideEncryption: dstEncryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+
+        decBytes, err := io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+        if !bytes.Equal(decBytes, buf) {
+                logError(testName, function, args, startTime, "", "Downloaded object mismatched for encrypted object", err)
+                return
+        }
+        reader.Close()
+
+        // Test key rotation for source object in-place.
+        var newSSE encrypt.ServerSide
+        if sseSrc != nil && sseSrc.Type() == encrypt.SSEC {
+                newSSE = encrypt.DefaultPBKDF([]byte("Don't Panic"), []byte(bucketName+"srcObject")) // replace key
+        }
+        if sseSrc != nil && sseSrc.Type() == encrypt.S3 {
+                newSSE = encrypt.NewSSE()
+        }
+        if newSSE != nil {
+                dst = minio.CopyDestOptions{
+                        Bucket:     bucketName,
+                        Object:     "srcObject",
+                        Encryption: newSSE,
+                }
+                args["destination"] = dst
+
+                _, err = c.CopyObject(context.Background(), dst, src)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "CopyObject failed", err)
+                        return
+                }
+
+                // Get copied object and check if content is equal
+                reader, _, _, err = coreClient.GetObject(context.Background(), bucketName, "srcObject", minio.GetObjectOptions{ServerSideEncryption: newSSE})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "GetObject failed", err)
+                        return
+                }
+
+                decBytes, err = io.ReadAll(reader)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                        return
+                }
+                if !bytes.Equal(decBytes, buf) {
+                        logError(testName, function, args, startTime, "", "Downloaded object mismatched for encrypted object", err)
+                        return
+                }
+                reader.Close()
+
+                // Test in-place decryption.
+                dst = minio.CopyDestOptions{
+                        Bucket: bucketName,
+                        Object: "srcObject",
+                }
+                args["destination"] = dst
+
+                src = minio.CopySrcOptions{
+                        Bucket:     bucketName,
+                        Object:     "srcObject",
+                        Encryption: newSSE,
+                }
+                args["source"] = src
+                _, err = c.CopyObject(context.Background(), dst, src)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "CopyObject Key rotation failed", err)
+                        return
+                }
+        }
+
+        // Get copied decrypted object and check if content is equal
+        reader, _, _, err = coreClient.GetObject(context.Background(), bucketName, "srcObject", minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+        defer reader.Close()
+
+        decBytes, err = io.ReadAll(reader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+        if !bytes.Equal(decBytes, buf) {
+                logError(testName, function, args, startTime, "", "Downloaded object mismatched for encrypted object", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test encrypted copy object
+func testUnencryptedToSSECCopyObject() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        sseDst := encrypt.DefaultPBKDF([]byte("correct horse battery staple"), []byte(bucketName+"dstObject"))
+        // c.TraceOn(os.Stderr)
+        testEncryptedCopyObjectWrapper(c, bucketName, nil, sseDst)
+}
+
+// Test encrypted copy object
+func testUnencryptedToSSES3CopyObject() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        var sseSrc encrypt.ServerSide
+        sseDst := encrypt.NewSSE()
+        // c.TraceOn(os.Stderr)
+        testEncryptedCopyObjectWrapper(c, bucketName, sseSrc, sseDst)
+}
+
+// Test encrypted copy object
+func testUnencryptedToUnencryptedCopyObject() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        var sseSrc, sseDst encrypt.ServerSide
+        // c.TraceOn(os.Stderr)
+        testEncryptedCopyObjectWrapper(c, bucketName, sseSrc, sseDst)
+}
+
+// Test encrypted copy object
+func testEncryptedSSECToSSECCopyObject() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        sseSrc := encrypt.DefaultPBKDF([]byte("correct horse battery staple"), []byte(bucketName+"srcObject"))
+        sseDst := encrypt.DefaultPBKDF([]byte("correct horse battery staple"), []byte(bucketName+"dstObject"))
+        // c.TraceOn(os.Stderr)
+        testEncryptedCopyObjectWrapper(c, bucketName, sseSrc, sseDst)
+}
+
+// Test encrypted copy object
+func testEncryptedSSECToSSES3CopyObject() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        sseSrc := encrypt.DefaultPBKDF([]byte("correct horse battery staple"), []byte(bucketName+"srcObject"))
+        sseDst := encrypt.NewSSE()
+        // c.TraceOn(os.Stderr)
+        testEncryptedCopyObjectWrapper(c, bucketName, sseSrc, sseDst)
+}
+
+// Test encrypted copy object
+func testEncryptedSSECToUnencryptedCopyObject() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        sseSrc := encrypt.DefaultPBKDF([]byte("correct horse battery staple"), []byte(bucketName+"srcObject"))
+        var sseDst encrypt.ServerSide
+        // c.TraceOn(os.Stderr)
+        testEncryptedCopyObjectWrapper(c, bucketName, sseSrc, sseDst)
+}
+
+// Test encrypted copy object
+func testEncryptedSSES3ToSSECCopyObject() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        sseSrc := encrypt.NewSSE()
+        sseDst := encrypt.DefaultPBKDF([]byte("correct horse battery staple"), []byte(bucketName+"dstObject"))
+        // c.TraceOn(os.Stderr)
+        testEncryptedCopyObjectWrapper(c, bucketName, sseSrc, sseDst)
+}
+
+// Test encrypted copy object
+func testEncryptedSSES3ToSSES3CopyObject() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        sseSrc := encrypt.NewSSE()
+        sseDst := encrypt.NewSSE()
+        // c.TraceOn(os.Stderr)
+        testEncryptedCopyObjectWrapper(c, bucketName, sseSrc, sseDst)
+}
+
+// Test encrypted copy object
+func testEncryptedSSES3ToUnencryptedCopyObject() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        sseSrc := encrypt.NewSSE()
+        var sseDst encrypt.ServerSide
+        // c.TraceOn(os.Stderr)
+        testEncryptedCopyObjectWrapper(c, bucketName, sseSrc, sseDst)
+}
+
+// Test encrypted copy object
+func testEncryptedCopyObjectV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+
+        sseSrc := encrypt.DefaultPBKDF([]byte("correct horse battery staple"), []byte(bucketName+"srcObject"))
+        sseDst := encrypt.DefaultPBKDF([]byte("correct horse battery staple"), []byte(bucketName+"dstObject"))
+        // c.TraceOn(os.Stderr)
+        testEncryptedCopyObjectWrapper(c, bucketName, sseSrc, sseDst)
+}
+
+func testDecryptedCopyObject() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v2 client object creation failed", err)
+                return
+        }
+
+        bucketName, objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-"), "object"
+        if err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"}); err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        encryption := encrypt.DefaultPBKDF([]byte("correct horse battery staple"), []byte(bucketName+objectName))
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(bytes.Repeat([]byte("a"), 1024*1024)), 1024*1024, minio.PutObjectOptions{
+                ServerSideEncryption: encryption,
+        })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject call failed", err)
+                return
+        }
+
+        src := minio.CopySrcOptions{
+                Bucket:     bucketName,
+                Object:     objectName,
+                Encryption: encrypt.SSECopy(encryption),
+        }
+        args["source"] = src
+
+        dst := minio.CopyDestOptions{
+                Bucket: bucketName,
+                Object: "decrypted-" + objectName,
+        }
+        args["destination"] = dst
+
+        if _, err = c.CopyObject(context.Background(), dst, src); err != nil {
+                logError(testName, function, args, startTime, "", "CopyObject failed", err)
+                return
+        }
+        if _, err = c.GetObject(context.Background(), bucketName, "decrypted-"+objectName, minio.GetObjectOptions{}); err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testSSECMultipartEncryptedToSSECCopyObjectPart() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObjectPart(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        client, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err)
+                return
+        }
+
+        // Instantiate new core client object.
+        c := minio.Core{client}
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test")
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName, client)
+        // Make a buffer with 6MB of data
+        buf := bytes.Repeat([]byte("abcdef"), 1024*1024)
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        password := "correct horse battery staple"
+        srcencryption := encrypt.DefaultPBKDF([]byte(password), []byte(bucketName+objectName))
+
+        // Upload a 6MB object using multipart mechanism
+        uploadID, err := c.NewMultipartUpload(context.Background(), bucketName, objectName, minio.PutObjectOptions{ServerSideEncryption: srcencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "NewMultipartUpload call failed", err)
+                return
+        }
+
+        var completeParts []minio.CompletePart
+
+        part, err := c.PutObjectPart(context.Background(), bucketName, objectName, uploadID, 1,
+                bytes.NewReader(buf[:5*1024*1024]), 5*1024*1024,
+                minio.PutObjectPartOptions{SSE: srcencryption},
+        )
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObjectPart call failed", err)
+                return
+        }
+        completeParts = append(completeParts, minio.CompletePart{PartNumber: part.PartNumber, ETag: part.ETag})
+
+        part, err = c.PutObjectPart(context.Background(), bucketName, objectName, uploadID, 2,
+                bytes.NewReader(buf[5*1024*1024:]), 1024*1024,
+                minio.PutObjectPartOptions{SSE: srcencryption},
+        )
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObjectPart call failed", err)
+                return
+        }
+        completeParts = append(completeParts, minio.CompletePart{PartNumber: part.PartNumber, ETag: part.ETag})
+
+        // Complete the multipart upload
+        _, err = c.CompleteMultipartUpload(context.Background(), bucketName, objectName, uploadID, completeParts, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CompleteMultipartUpload call failed", err)
+                return
+        }
+
+        // Stat the object and check its length matches
+        objInfo, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{ServerSideEncryption: srcencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        destBucketName := bucketName
+        destObjectName := objectName + "-dest"
+        dstencryption := encrypt.DefaultPBKDF([]byte(password), []byte(destBucketName+destObjectName))
+
+        uploadID, err = c.NewMultipartUpload(context.Background(), destBucketName, destObjectName, minio.PutObjectOptions{ServerSideEncryption: dstencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "NewMultipartUpload call failed", err)
+                return
+        }
+
+        // Content of the destination object will be two copies of
+        // `objectName` concatenated, followed by first byte of
+        // `objectName`.
+        metadata := make(map[string]string)
+        header := make(http.Header)
+        encrypt.SSECopy(srcencryption).Marshal(header)
+        dstencryption.Marshal(header)
+        for k, v := range header {
+                metadata[k] = v[0]
+        }
+
+        metadata["x-amz-copy-source-if-match"] = objInfo.ETag
+
+        // First of three parts
+        fstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 1, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Second of three parts
+        sndPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 2, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Last of three parts
+        lstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 3, 0, 1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Complete the multipart upload
+        _, err = c.CompleteMultipartUpload(context.Background(), destBucketName, destObjectName, uploadID, []minio.CompletePart{fstPart, sndPart, lstPart}, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CompleteMultipartUpload call failed", err)
+                return
+        }
+
+        // Stat the object and check its length matches
+        objInfo, err = c.StatObject(context.Background(), destBucketName, destObjectName, minio.StatObjectOptions{ServerSideEncryption: dstencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if objInfo.Size != (6*1024*1024)*2+1 {
+                logError(testName, function, args, startTime, "", "Destination object has incorrect size!", err)
+                return
+        }
+
+        // Now we read the data back
+        getOpts := minio.GetObjectOptions{ServerSideEncryption: dstencryption}
+        getOpts.SetRange(0, 6*1024*1024-1)
+        r, _, _, err := c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf := make([]byte, 6*1024*1024)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf, buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in first 6MB", err)
+                return
+        }
+
+        getOpts.SetRange(6*1024*1024, 0)
+        r, _, _, err = c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf = make([]byte, 6*1024*1024+1)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf[:6*1024*1024], buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in second 6MB", err)
+                return
+        }
+        if getBuf[6*1024*1024] != buf[0] {
+                logError(testName, function, args, startTime, "", "Got unexpected data in last byte of copied object!", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+
+        // Do not need to remove destBucketName its same as bucketName.
+}
+
+// Test Core CopyObjectPart implementation
+func testSSECEncryptedToSSECCopyObjectPart() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObjectPart(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        client, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err)
+                return
+        }
+
+        // Instantiate new core client object.
+        c := minio.Core{client}
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test")
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName, client)
+        // Make a buffer with 5MB of data
+        buf := bytes.Repeat([]byte("abcde"), 1024*1024)
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        password := "correct horse battery staple"
+        srcencryption := encrypt.DefaultPBKDF([]byte(password), []byte(bucketName+objectName))
+        putmetadata := map[string]string{
+                "Content-Type": "binary/octet-stream",
+        }
+        opts := minio.PutObjectOptions{
+                UserMetadata:         putmetadata,
+                ServerSideEncryption: srcencryption,
+        }
+        uploadInfo, err := c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), "", "", opts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject call failed", err)
+                return
+        }
+
+        st, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{ServerSideEncryption: srcencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if st.Size != int64(len(buf)) {
+                logError(testName, function, args, startTime, "", fmt.Sprintf("Error: number of bytes does not match, want %v, got %v\n", len(buf), st.Size), err)
+                return
+        }
+
+        destBucketName := bucketName
+        destObjectName := objectName + "-dest"
+        dstencryption := encrypt.DefaultPBKDF([]byte(password), []byte(destBucketName+destObjectName))
+
+        uploadID, err := c.NewMultipartUpload(context.Background(), destBucketName, destObjectName, minio.PutObjectOptions{ServerSideEncryption: dstencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "NewMultipartUpload call failed", err)
+                return
+        }
+
+        // Content of the destination object will be two copies of
+        // `objectName` concatenated, followed by first byte of
+        // `objectName`.
+        metadata := make(map[string]string)
+        header := make(http.Header)
+        encrypt.SSECopy(srcencryption).Marshal(header)
+        dstencryption.Marshal(header)
+        for k, v := range header {
+                metadata[k] = v[0]
+        }
+
+        metadata["x-amz-copy-source-if-match"] = uploadInfo.ETag
+
+        // First of three parts
+        fstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 1, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Second of three parts
+        sndPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 2, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Last of three parts
+        lstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 3, 0, 1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Complete the multipart upload
+        _, err = c.CompleteMultipartUpload(context.Background(), destBucketName, destObjectName, uploadID, []minio.CompletePart{fstPart, sndPart, lstPart}, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CompleteMultipartUpload call failed", err)
+                return
+        }
+
+        // Stat the object and check its length matches
+        objInfo, err := c.StatObject(context.Background(), destBucketName, destObjectName, minio.StatObjectOptions{ServerSideEncryption: dstencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if objInfo.Size != (5*1024*1024)*2+1 {
+                logError(testName, function, args, startTime, "", "Destination object has incorrect size!", err)
+                return
+        }
+
+        // Now we read the data back
+        getOpts := minio.GetObjectOptions{ServerSideEncryption: dstencryption}
+        getOpts.SetRange(0, 5*1024*1024-1)
+        r, _, _, err := c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf := make([]byte, 5*1024*1024)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf, buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in first 5MB", err)
+                return
+        }
+
+        getOpts.SetRange(5*1024*1024, 0)
+        r, _, _, err = c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf = make([]byte, 5*1024*1024+1)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf[:5*1024*1024], buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in second 5MB", err)
+                return
+        }
+        if getBuf[5*1024*1024] != buf[0] {
+                logError(testName, function, args, startTime, "", "Got unexpected data in last byte of copied object!", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+
+        // Do not need to remove destBucketName its same as bucketName.
+}
+
+// Test Core CopyObjectPart implementation for SSEC encrypted to unencrypted copy
+func testSSECEncryptedToUnencryptedCopyPart() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObjectPart(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        client, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err)
+                return
+        }
+
+        // Instantiate new core client object.
+        c := minio.Core{client}
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test")
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName, client)
+        // Make a buffer with 5MB of data
+        buf := bytes.Repeat([]byte("abcde"), 1024*1024)
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        password := "correct horse battery staple"
+        srcencryption := encrypt.DefaultPBKDF([]byte(password), []byte(bucketName+objectName))
+
+        opts := minio.PutObjectOptions{
+                UserMetadata: map[string]string{
+                        "Content-Type": "binary/octet-stream",
+                },
+                ServerSideEncryption: srcencryption,
+        }
+        uploadInfo, err := c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), "", "", opts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject call failed", err)
+                return
+        }
+
+        st, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{ServerSideEncryption: srcencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if st.Size != int64(len(buf)) {
+                logError(testName, function, args, startTime, "", fmt.Sprintf("Error: number of bytes does not match, want %v, got %v\n", len(buf), st.Size), err)
+                return
+        }
+
+        destBucketName := bucketName
+        destObjectName := objectName + "-dest"
+        var dstencryption encrypt.ServerSide
+
+        uploadID, err := c.NewMultipartUpload(context.Background(), destBucketName, destObjectName, minio.PutObjectOptions{ServerSideEncryption: dstencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "NewMultipartUpload call failed", err)
+                return
+        }
+
+        // Content of the destination object will be two copies of
+        // `objectName` concatenated, followed by first byte of
+        // `objectName`.
+        metadata := make(map[string]string)
+        header := make(http.Header)
+        encrypt.SSECopy(srcencryption).Marshal(header)
+        for k, v := range header {
+                metadata[k] = v[0]
+        }
+
+        metadata["x-amz-copy-source-if-match"] = uploadInfo.ETag
+
+        // First of three parts
+        fstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 1, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Second of three parts
+        sndPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 2, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Last of three parts
+        lstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 3, 0, 1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Complete the multipart upload
+        _, err = c.CompleteMultipartUpload(context.Background(), destBucketName, destObjectName, uploadID, []minio.CompletePart{fstPart, sndPart, lstPart}, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CompleteMultipartUpload call failed", err)
+                return
+        }
+
+        // Stat the object and check its length matches
+        objInfo, err := c.StatObject(context.Background(), destBucketName, destObjectName, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if objInfo.Size != (5*1024*1024)*2+1 {
+                logError(testName, function, args, startTime, "", "Destination object has incorrect size!", err)
+                return
+        }
+
+        // Now we read the data back
+        getOpts := minio.GetObjectOptions{}
+        getOpts.SetRange(0, 5*1024*1024-1)
+        r, _, _, err := c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf := make([]byte, 5*1024*1024)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf, buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in first 5MB", err)
+                return
+        }
+
+        getOpts.SetRange(5*1024*1024, 0)
+        r, _, _, err = c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf = make([]byte, 5*1024*1024+1)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf[:5*1024*1024], buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in second 5MB", err)
+                return
+        }
+        if getBuf[5*1024*1024] != buf[0] {
+                logError(testName, function, args, startTime, "", "Got unexpected data in last byte of copied object!", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+
+        // Do not need to remove destBucketName its same as bucketName.
+}
+
+// Test Core CopyObjectPart implementation for SSEC encrypted to SSE-S3 encrypted copy
+func testSSECEncryptedToSSES3CopyObjectPart() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObjectPart(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        client, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err)
+                return
+        }
+
+        // Instantiate new core client object.
+        c := minio.Core{client}
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test")
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName, client)
+        // Make a buffer with 5MB of data
+        buf := bytes.Repeat([]byte("abcde"), 1024*1024)
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        password := "correct horse battery staple"
+        srcencryption := encrypt.DefaultPBKDF([]byte(password), []byte(bucketName+objectName))
+        putmetadata := map[string]string{
+                "Content-Type": "binary/octet-stream",
+        }
+        opts := minio.PutObjectOptions{
+                UserMetadata:         putmetadata,
+                ServerSideEncryption: srcencryption,
+        }
+
+        uploadInfo, err := c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), "", "", opts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject call failed", err)
+                return
+        }
+
+        st, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{ServerSideEncryption: srcencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if st.Size != int64(len(buf)) {
+                logError(testName, function, args, startTime, "", fmt.Sprintf("Error: number of bytes does not match, want %v, got %v\n", len(buf), st.Size), err)
+                return
+        }
+
+        destBucketName := bucketName
+        destObjectName := objectName + "-dest"
+        dstencryption := encrypt.NewSSE()
+
+        uploadID, err := c.NewMultipartUpload(context.Background(), destBucketName, destObjectName, minio.PutObjectOptions{ServerSideEncryption: dstencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "NewMultipartUpload call failed", err)
+                return
+        }
+
+        // Content of the destination object will be two copies of
+        // `objectName` concatenated, followed by first byte of
+        // `objectName`.
+        metadata := make(map[string]string)
+        header := make(http.Header)
+        encrypt.SSECopy(srcencryption).Marshal(header)
+        dstencryption.Marshal(header)
+
+        for k, v := range header {
+                metadata[k] = v[0]
+        }
+
+        metadata["x-amz-copy-source-if-match"] = uploadInfo.ETag
+
+        // First of three parts
+        fstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 1, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Second of three parts
+        sndPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 2, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Last of three parts
+        lstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 3, 0, 1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Complete the multipart upload
+        _, err = c.CompleteMultipartUpload(context.Background(), destBucketName, destObjectName, uploadID, []minio.CompletePart{fstPart, sndPart, lstPart}, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CompleteMultipartUpload call failed", err)
+                return
+        }
+
+        // Stat the object and check its length matches
+        objInfo, err := c.StatObject(context.Background(), destBucketName, destObjectName, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if objInfo.Size != (5*1024*1024)*2+1 {
+                logError(testName, function, args, startTime, "", "Destination object has incorrect size!", err)
+                return
+        }
+
+        // Now we read the data back
+        getOpts := minio.GetObjectOptions{}
+        getOpts.SetRange(0, 5*1024*1024-1)
+        r, _, _, err := c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf := make([]byte, 5*1024*1024)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf, buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in first 5MB", err)
+                return
+        }
+
+        getOpts.SetRange(5*1024*1024, 0)
+        r, _, _, err = c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf = make([]byte, 5*1024*1024+1)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf[:5*1024*1024], buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in second 5MB", err)
+                return
+        }
+        if getBuf[5*1024*1024] != buf[0] {
+                logError(testName, function, args, startTime, "", "Got unexpected data in last byte of copied object!", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+
+        // Do not need to remove destBucketName its same as bucketName.
+}
+
+// Test Core CopyObjectPart implementation for unencrypted to SSEC encryption copy part
+func testUnencryptedToSSECCopyObjectPart() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObjectPart(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        client, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err)
+                return
+        }
+
+        // Instantiate new core client object.
+        c := minio.Core{client}
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test")
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName, client)
+        // Make a buffer with 5MB of data
+        buf := bytes.Repeat([]byte("abcde"), 1024*1024)
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        password := "correct horse battery staple"
+        putmetadata := map[string]string{
+                "Content-Type": "binary/octet-stream",
+        }
+        opts := minio.PutObjectOptions{
+                UserMetadata: putmetadata,
+        }
+        uploadInfo, err := c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), "", "", opts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject call failed", err)
+                return
+        }
+
+        st, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if st.Size != int64(len(buf)) {
+                logError(testName, function, args, startTime, "", fmt.Sprintf("Error: number of bytes does not match, want %v, got %v\n", len(buf), st.Size), err)
+                return
+        }
+
+        destBucketName := bucketName
+        destObjectName := objectName + "-dest"
+        dstencryption := encrypt.DefaultPBKDF([]byte(password), []byte(destBucketName+destObjectName))
+
+        uploadID, err := c.NewMultipartUpload(context.Background(), destBucketName, destObjectName, minio.PutObjectOptions{ServerSideEncryption: dstencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "NewMultipartUpload call failed", err)
+                return
+        }
+
+        // Content of the destination object will be two copies of
+        // `objectName` concatenated, followed by first byte of
+        // `objectName`.
+        metadata := make(map[string]string)
+        header := make(http.Header)
+        dstencryption.Marshal(header)
+        for k, v := range header {
+                metadata[k] = v[0]
+        }
+
+        metadata["x-amz-copy-source-if-match"] = uploadInfo.ETag
+
+        // First of three parts
+        fstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 1, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Second of three parts
+        sndPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 2, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Last of three parts
+        lstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 3, 0, 1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Complete the multipart upload
+        _, err = c.CompleteMultipartUpload(context.Background(), destBucketName, destObjectName, uploadID, []minio.CompletePart{fstPart, sndPart, lstPart}, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CompleteMultipartUpload call failed", err)
+                return
+        }
+
+        // Stat the object and check its length matches
+        objInfo, err := c.StatObject(context.Background(), destBucketName, destObjectName, minio.StatObjectOptions{ServerSideEncryption: dstencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if objInfo.Size != (5*1024*1024)*2+1 {
+                logError(testName, function, args, startTime, "", "Destination object has incorrect size!", err)
+                return
+        }
+
+        // Now we read the data back
+        getOpts := minio.GetObjectOptions{ServerSideEncryption: dstencryption}
+        getOpts.SetRange(0, 5*1024*1024-1)
+        r, _, _, err := c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf := make([]byte, 5*1024*1024)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf, buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in first 5MB", err)
+                return
+        }
+
+        getOpts.SetRange(5*1024*1024, 0)
+        r, _, _, err = c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf = make([]byte, 5*1024*1024+1)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf[:5*1024*1024], buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in second 5MB", err)
+                return
+        }
+        if getBuf[5*1024*1024] != buf[0] {
+                logError(testName, function, args, startTime, "", "Got unexpected data in last byte of copied object!", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+
+        // Do not need to remove destBucketName its same as bucketName.
+}
+
+// Test Core CopyObjectPart implementation for unencrypted to unencrypted copy
+func testUnencryptedToUnencryptedCopyPart() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObjectPart(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        client, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err)
+                return
+        }
+
+        // Instantiate new core client object.
+        c := minio.Core{client}
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test")
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName, client)
+        // Make a buffer with 5MB of data
+        buf := bytes.Repeat([]byte("abcde"), 1024*1024)
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        putmetadata := map[string]string{
+                "Content-Type": "binary/octet-stream",
+        }
+        opts := minio.PutObjectOptions{
+                UserMetadata: putmetadata,
+        }
+        uploadInfo, err := c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), "", "", opts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject call failed", err)
+                return
+        }
+        st, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if st.Size != int64(len(buf)) {
+                logError(testName, function, args, startTime, "", fmt.Sprintf("Error: number of bytes does not match, want %v, got %v\n", len(buf), st.Size), err)
+                return
+        }
+
+        destBucketName := bucketName
+        destObjectName := objectName + "-dest"
+
+        uploadID, err := c.NewMultipartUpload(context.Background(), destBucketName, destObjectName, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "NewMultipartUpload call failed", err)
+                return
+        }
+
+        // Content of the destination object will be two copies of
+        // `objectName` concatenated, followed by first byte of
+        // `objectName`.
+        metadata := make(map[string]string)
+        header := make(http.Header)
+        for k, v := range header {
+                metadata[k] = v[0]
+        }
+
+        metadata["x-amz-copy-source-if-match"] = uploadInfo.ETag
+
+        // First of three parts
+        fstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 1, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Second of three parts
+        sndPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 2, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Last of three parts
+        lstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 3, 0, 1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Complete the multipart upload
+        _, err = c.CompleteMultipartUpload(context.Background(), destBucketName, destObjectName, uploadID, []minio.CompletePart{fstPart, sndPart, lstPart}, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CompleteMultipartUpload call failed", err)
+                return
+        }
+
+        // Stat the object and check its length matches
+        objInfo, err := c.StatObject(context.Background(), destBucketName, destObjectName, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if objInfo.Size != (5*1024*1024)*2+1 {
+                logError(testName, function, args, startTime, "", "Destination object has incorrect size!", err)
+                return
+        }
+
+        // Now we read the data back
+        getOpts := minio.GetObjectOptions{}
+        getOpts.SetRange(0, 5*1024*1024-1)
+        r, _, _, err := c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf := make([]byte, 5*1024*1024)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf, buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in first 5MB", err)
+                return
+        }
+
+        getOpts.SetRange(5*1024*1024, 0)
+        r, _, _, err = c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf = make([]byte, 5*1024*1024+1)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf[:5*1024*1024], buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in second 5MB", err)
+                return
+        }
+        if getBuf[5*1024*1024] != buf[0] {
+                logError(testName, function, args, startTime, "", "Got unexpected data in last byte of copied object!", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+
+        // Do not need to remove destBucketName its same as bucketName.
+}
+
+// Test Core CopyObjectPart implementation for unencrypted to SSE-S3 encrypted copy
+func testUnencryptedToSSES3CopyObjectPart() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObjectPart(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        client, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err)
+                return
+        }
+
+        // Instantiate new core client object.
+        c := minio.Core{client}
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test")
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName, client)
+        // Make a buffer with 5MB of data
+        buf := bytes.Repeat([]byte("abcde"), 1024*1024)
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        opts := minio.PutObjectOptions{
+                UserMetadata: map[string]string{
+                        "Content-Type": "binary/octet-stream",
+                },
+        }
+        uploadInfo, err := c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), "", "", opts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject call failed", err)
+                return
+        }
+        st, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if st.Size != int64(len(buf)) {
+                logError(testName, function, args, startTime, "", fmt.Sprintf("Error: number of bytes does not match, want %v, got %v\n", len(buf), st.Size), err)
+                return
+        }
+
+        destBucketName := bucketName
+        destObjectName := objectName + "-dest"
+        dstencryption := encrypt.NewSSE()
+
+        uploadID, err := c.NewMultipartUpload(context.Background(), destBucketName, destObjectName, minio.PutObjectOptions{ServerSideEncryption: dstencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "NewMultipartUpload call failed", err)
+                return
+        }
+
+        // Content of the destination object will be two copies of
+        // `objectName` concatenated, followed by first byte of
+        // `objectName`.
+        metadata := make(map[string]string)
+        header := make(http.Header)
+        dstencryption.Marshal(header)
+
+        for k, v := range header {
+                metadata[k] = v[0]
+        }
+
+        metadata["x-amz-copy-source-if-match"] = uploadInfo.ETag
+
+        // First of three parts
+        fstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 1, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Second of three parts
+        sndPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 2, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Last of three parts
+        lstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 3, 0, 1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Complete the multipart upload
+        _, err = c.CompleteMultipartUpload(context.Background(), destBucketName, destObjectName, uploadID, []minio.CompletePart{fstPart, sndPart, lstPart}, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CompleteMultipartUpload call failed", err)
+                return
+        }
+
+        // Stat the object and check its length matches
+        objInfo, err := c.StatObject(context.Background(), destBucketName, destObjectName, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if objInfo.Size != (5*1024*1024)*2+1 {
+                logError(testName, function, args, startTime, "", "Destination object has incorrect size!", err)
+                return
+        }
+
+        // Now we read the data back
+        getOpts := minio.GetObjectOptions{}
+        getOpts.SetRange(0, 5*1024*1024-1)
+        r, _, _, err := c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf := make([]byte, 5*1024*1024)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf, buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in first 5MB", err)
+                return
+        }
+
+        getOpts.SetRange(5*1024*1024, 0)
+        r, _, _, err = c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf = make([]byte, 5*1024*1024+1)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf[:5*1024*1024], buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in second 5MB", err)
+                return
+        }
+        if getBuf[5*1024*1024] != buf[0] {
+                logError(testName, function, args, startTime, "", "Got unexpected data in last byte of copied object!", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+
+        // Do not need to remove destBucketName its same as bucketName.
+}
+
+// Test Core CopyObjectPart implementation for SSE-S3 to SSEC encryption copy part
+func testSSES3EncryptedToSSECCopyObjectPart() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObjectPart(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        client, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err)
+                return
+        }
+
+        // Instantiate new core client object.
+        c := minio.Core{client}
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test")
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName, client)
+        // Make a buffer with 5MB of data
+        buf := bytes.Repeat([]byte("abcde"), 1024*1024)
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        password := "correct horse battery staple"
+        srcEncryption := encrypt.NewSSE()
+        opts := minio.PutObjectOptions{
+                UserMetadata: map[string]string{
+                        "Content-Type": "binary/octet-stream",
+                },
+                ServerSideEncryption: srcEncryption,
+        }
+        uploadInfo, err := c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), "", "", opts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject call failed", err)
+                return
+        }
+
+        st, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{ServerSideEncryption: srcEncryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if st.Size != int64(len(buf)) {
+                logError(testName, function, args, startTime, "", fmt.Sprintf("Error: number of bytes does not match, want %v, got %v\n", len(buf), st.Size), err)
+                return
+        }
+
+        destBucketName := bucketName
+        destObjectName := objectName + "-dest"
+        dstencryption := encrypt.DefaultPBKDF([]byte(password), []byte(destBucketName+destObjectName))
+
+        uploadID, err := c.NewMultipartUpload(context.Background(), destBucketName, destObjectName, minio.PutObjectOptions{ServerSideEncryption: dstencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "NewMultipartUpload call failed", err)
+                return
+        }
+
+        // Content of the destination object will be two copies of
+        // `objectName` concatenated, followed by first byte of
+        // `objectName`.
+        metadata := make(map[string]string)
+        header := make(http.Header)
+        dstencryption.Marshal(header)
+        for k, v := range header {
+                metadata[k] = v[0]
+        }
+
+        metadata["x-amz-copy-source-if-match"] = uploadInfo.ETag
+
+        // First of three parts
+        fstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 1, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Second of three parts
+        sndPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 2, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Last of three parts
+        lstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 3, 0, 1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Complete the multipart upload
+        _, err = c.CompleteMultipartUpload(context.Background(), destBucketName, destObjectName, uploadID, []minio.CompletePart{fstPart, sndPart, lstPart}, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CompleteMultipartUpload call failed", err)
+                return
+        }
+
+        // Stat the object and check its length matches
+        objInfo, err := c.StatObject(context.Background(), destBucketName, destObjectName, minio.StatObjectOptions{ServerSideEncryption: dstencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if objInfo.Size != (5*1024*1024)*2+1 {
+                logError(testName, function, args, startTime, "", "Destination object has incorrect size!", err)
+                return
+        }
+
+        // Now we read the data back
+        getOpts := minio.GetObjectOptions{ServerSideEncryption: dstencryption}
+        getOpts.SetRange(0, 5*1024*1024-1)
+        r, _, _, err := c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf := make([]byte, 5*1024*1024)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf, buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in first 5MB", err)
+                return
+        }
+
+        getOpts.SetRange(5*1024*1024, 0)
+        r, _, _, err = c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf = make([]byte, 5*1024*1024+1)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf[:5*1024*1024], buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in second 5MB", err)
+                return
+        }
+        if getBuf[5*1024*1024] != buf[0] {
+                logError(testName, function, args, startTime, "", "Got unexpected data in last byte of copied object!", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+
+        // Do not need to remove destBucketName its same as bucketName.
+}
+
+// Test Core CopyObjectPart implementation for unencrypted to unencrypted copy
+func testSSES3EncryptedToUnencryptedCopyPart() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObjectPart(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        client, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err)
+                return
+        }
+
+        // Instantiate new core client object.
+        c := minio.Core{client}
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test")
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName, client)
+        // Make a buffer with 5MB of data
+        buf := bytes.Repeat([]byte("abcde"), 1024*1024)
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        srcEncryption := encrypt.NewSSE()
+        opts := minio.PutObjectOptions{
+                UserMetadata: map[string]string{
+                        "Content-Type": "binary/octet-stream",
+                },
+                ServerSideEncryption: srcEncryption,
+        }
+        uploadInfo, err := c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), "", "", opts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject call failed", err)
+                return
+        }
+        st, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{ServerSideEncryption: srcEncryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if st.Size != int64(len(buf)) {
+                logError(testName, function, args, startTime, "", fmt.Sprintf("Error: number of bytes does not match, want %v, got %v\n", len(buf), st.Size), err)
+                return
+        }
+
+        destBucketName := bucketName
+        destObjectName := objectName + "-dest"
+
+        uploadID, err := c.NewMultipartUpload(context.Background(), destBucketName, destObjectName, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "NewMultipartUpload call failed", err)
+                return
+        }
+
+        // Content of the destination object will be two copies of
+        // `objectName` concatenated, followed by first byte of
+        // `objectName`.
+        metadata := make(map[string]string)
+        header := make(http.Header)
+        for k, v := range header {
+                metadata[k] = v[0]
+        }
+
+        metadata["x-amz-copy-source-if-match"] = uploadInfo.ETag
+
+        // First of three parts
+        fstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 1, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Second of three parts
+        sndPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 2, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Last of three parts
+        lstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 3, 0, 1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Complete the multipart upload
+        _, err = c.CompleteMultipartUpload(context.Background(), destBucketName, destObjectName, uploadID, []minio.CompletePart{fstPart, sndPart, lstPart}, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CompleteMultipartUpload call failed", err)
+                return
+        }
+
+        // Stat the object and check its length matches
+        objInfo, err := c.StatObject(context.Background(), destBucketName, destObjectName, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if objInfo.Size != (5*1024*1024)*2+1 {
+                logError(testName, function, args, startTime, "", "Destination object has incorrect size!", err)
+                return
+        }
+
+        // Now we read the data back
+        getOpts := minio.GetObjectOptions{}
+        getOpts.SetRange(0, 5*1024*1024-1)
+        r, _, _, err := c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf := make([]byte, 5*1024*1024)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf, buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in first 5MB", err)
+                return
+        }
+
+        getOpts.SetRange(5*1024*1024, 0)
+        r, _, _, err = c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf = make([]byte, 5*1024*1024+1)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf[:5*1024*1024], buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in second 5MB", err)
+                return
+        }
+        if getBuf[5*1024*1024] != buf[0] {
+                logError(testName, function, args, startTime, "", "Got unexpected data in last byte of copied object!", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+
+        // Do not need to remove destBucketName its same as bucketName.
+}
+
+// Test Core CopyObjectPart implementation for unencrypted to SSE-S3 encrypted copy
+func testSSES3EncryptedToSSES3CopyObjectPart() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObjectPart(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        client, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err)
+                return
+        }
+
+        // Instantiate new core client object.
+        c := minio.Core{client}
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test")
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName, client)
+        // Make a buffer with 5MB of data
+        buf := bytes.Repeat([]byte("abcde"), 1024*1024)
+
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        srcEncryption := encrypt.NewSSE()
+        opts := minio.PutObjectOptions{
+                UserMetadata: map[string]string{
+                        "Content-Type": "binary/octet-stream",
+                },
+                ServerSideEncryption: srcEncryption,
+        }
+
+        uploadInfo, err := c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), "", "", opts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject call failed", err)
+                return
+        }
+        st, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{ServerSideEncryption: srcEncryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+        if st.Size != int64(len(buf)) {
+                logError(testName, function, args, startTime, "", fmt.Sprintf("Error: number of bytes does not match, want %v, got %v\n", len(buf), st.Size), err)
+                return
+        }
+
+        destBucketName := bucketName
+        destObjectName := objectName + "-dest"
+        dstencryption := encrypt.NewSSE()
+
+        uploadID, err := c.NewMultipartUpload(context.Background(), destBucketName, destObjectName, minio.PutObjectOptions{ServerSideEncryption: dstencryption})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "NewMultipartUpload call failed", err)
+                return
+        }
+
+        // Content of the destination object will be two copies of
+        // `objectName` concatenated, followed by first byte of
+        // `objectName`.
+        metadata := make(map[string]string)
+        header := make(http.Header)
+        dstencryption.Marshal(header)
+
+        for k, v := range header {
+                metadata[k] = v[0]
+        }
+
+        metadata["x-amz-copy-source-if-match"] = uploadInfo.ETag
+
+        // First of three parts
+        fstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 1, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Second of three parts
+        sndPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 2, 0, -1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Last of three parts
+        lstPart, err := c.CopyObjectPart(context.Background(), bucketName, objectName, destBucketName, destObjectName, uploadID, 3, 0, 1, metadata)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObjectPart call failed", err)
+                return
+        }
+
+        // Complete the multipart upload
+        _, err = c.CompleteMultipartUpload(context.Background(), destBucketName, destObjectName, uploadID, []minio.CompletePart{fstPart, sndPart, lstPart}, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CompleteMultipartUpload call failed", err)
+                return
+        }
+
+        // Stat the object and check its length matches
+        objInfo, err := c.StatObject(context.Background(), destBucketName, destObjectName, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject call failed", err)
+                return
+        }
+
+        if objInfo.Size != (5*1024*1024)*2+1 {
+                logError(testName, function, args, startTime, "", "Destination object has incorrect size!", err)
+                return
+        }
+
+        // Now we read the data back
+        getOpts := minio.GetObjectOptions{}
+        getOpts.SetRange(0, 5*1024*1024-1)
+        r, _, _, err := c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf := make([]byte, 5*1024*1024)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf, buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in first 5MB", err)
+                return
+        }
+
+        getOpts.SetRange(5*1024*1024, 0)
+        r, _, _, err = c.GetObject(context.Background(), destBucketName, destObjectName, getOpts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject call failed", err)
+                return
+        }
+        getBuf = make([]byte, 5*1024*1024+1)
+        _, err = readFull(r, getBuf)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Read buffer failed", err)
+                return
+        }
+        if !bytes.Equal(getBuf[:5*1024*1024], buf) {
+                logError(testName, function, args, startTime, "", "Got unexpected data in second 5MB", err)
+                return
+        }
+        if getBuf[5*1024*1024] != buf[0] {
+                logError(testName, function, args, startTime, "", "Got unexpected data in last byte of copied object!", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+
+        // Do not need to remove destBucketName its same as bucketName.
+}
+
+func testUserMetadataCopying() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        // c.TraceOn(os.Stderr)
+        testUserMetadataCopyingWrapper(c)
+}
+
+func testUserMetadataCopyingWrapper(c *minio.Client) {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        // Make a new bucket in 'us-east-1' (source bucket).
+        err := c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        fetchMeta := func(object string) (h http.Header) {
+                objInfo, err := c.StatObject(context.Background(), bucketName, object, minio.StatObjectOptions{})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "Stat failed", err)
+                        return
+                }
+                h = make(http.Header)
+                for k, vs := range objInfo.Metadata {
+                        if strings.HasPrefix(strings.ToLower(k), "x-amz-meta-") {
+                                h.Add(k, vs[0])
+                        }
+                }
+                return h
+        }
+
+        // 1. create a client encrypted object to copy by uploading
+        const srcSize = 1024 * 1024
+        buf := bytes.Repeat([]byte("abcde"), srcSize) // gives a buffer of 5MiB
+        metadata := make(http.Header)
+        metadata.Set("x-amz-meta-myheader", "myvalue")
+        m := make(map[string]string)
+        m["x-amz-meta-myheader"] = "myvalue"
+        _, err = c.PutObject(context.Background(), bucketName, "srcObject",
+                bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{UserMetadata: m})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObjectWithMetadata failed", err)
+                return
+        }
+        if !reflect.DeepEqual(metadata, fetchMeta("srcObject")) {
+                logError(testName, function, args, startTime, "", "Metadata match failed", err)
+                return
+        }
+
+        // 2. create source
+        src := minio.CopySrcOptions{
+                Bucket: bucketName,
+                Object: "srcObject",
+        }
+
+        // 2.1 create destination with metadata set
+        dst1 := minio.CopyDestOptions{
+                Bucket:          bucketName,
+                Object:          "dstObject-1",
+                UserMetadata:    map[string]string{"notmyheader": "notmyvalue"},
+                ReplaceMetadata: true,
+        }
+
+        // 3. Check that copying to an object with metadata set resets
+        // the headers on the copy.
+        args["source"] = src
+        args["destination"] = dst1
+        _, err = c.CopyObject(context.Background(), dst1, src)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObject failed", err)
+                return
+        }
+
+        expectedHeaders := make(http.Header)
+        expectedHeaders.Set("x-amz-meta-notmyheader", "notmyvalue")
+        if !reflect.DeepEqual(expectedHeaders, fetchMeta("dstObject-1")) {
+                logError(testName, function, args, startTime, "", "Metadata match failed", err)
+                return
+        }
+
+        // 4. create destination with no metadata set and same source
+        dst2 := minio.CopyDestOptions{
+                Bucket: bucketName,
+                Object: "dstObject-2",
+        }
+
+        // 5. Check that copying to an object with no metadata set,
+        // copies metadata.
+        args["source"] = src
+        args["destination"] = dst2
+        _, err = c.CopyObject(context.Background(), dst2, src)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "CopyObject failed", err)
+                return
+        }
+
+        expectedHeaders = metadata
+        if !reflect.DeepEqual(expectedHeaders, fetchMeta("dstObject-2")) {
+                logError(testName, function, args, startTime, "", "Metadata match failed", err)
+                return
+        }
+
+        // 6. Compose a pair of sources.
+        dst3 := minio.CopyDestOptions{
+                Bucket:          bucketName,
+                Object:          "dstObject-3",
+                ReplaceMetadata: true,
+        }
+
+        function = "ComposeObject(destination, sources)"
+        args["source"] = []minio.CopySrcOptions{src, src}
+        args["destination"] = dst3
+        _, err = c.ComposeObject(context.Background(), dst3, src, src)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ComposeObject failed", err)
+                return
+        }
+
+        // Check that no headers are copied in this case
+        if !reflect.DeepEqual(make(http.Header), fetchMeta("dstObject-3")) {
+                logError(testName, function, args, startTime, "", "Metadata match failed", err)
+                return
+        }
+
+        // 7. Compose a pair of sources with dest user metadata set.
+        dst4 := minio.CopyDestOptions{
+                Bucket:          bucketName,
+                Object:          "dstObject-4",
+                UserMetadata:    map[string]string{"notmyheader": "notmyvalue"},
+                ReplaceMetadata: true,
+        }
+
+        function = "ComposeObject(destination, sources)"
+        args["source"] = []minio.CopySrcOptions{src, src}
+        args["destination"] = dst4
+        _, err = c.ComposeObject(context.Background(), dst4, src, src)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ComposeObject failed", err)
+                return
+        }
+
+        // Check that no headers are copied in this case
+        expectedHeaders = make(http.Header)
+        expectedHeaders.Set("x-amz-meta-notmyheader", "notmyvalue")
+        if !reflect.DeepEqual(expectedHeaders, fetchMeta("dstObject-4")) {
+                logError(testName, function, args, startTime, "", "Metadata match failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testUserMetadataCopyingV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "CopyObject(destination, source)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client v2 object creation failed", err)
+                return
+        }
+
+        // c.TraceOn(os.Stderr)
+        testUserMetadataCopyingWrapper(c)
+}
+
+func testStorageClassMetadataPutObject() {
+        // initialize logging params
+        startTime := time.Now()
+        function := "testStorageClassMetadataPutObject()"
+        args := map[string]interface{}{}
+        testName := getFuncName()
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err)
+                return
+        }
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test")
+        // Make a new bucket in 'us-east-1' (source bucket).
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        fetchMeta := func(object string) (h http.Header) {
+                objInfo, err := c.StatObject(context.Background(), bucketName, object, minio.StatObjectOptions{})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "Stat failed", err)
+                        return
+                }
+                h = make(http.Header)
+                for k, vs := range objInfo.Metadata {
+                        if strings.HasPrefix(strings.ToLower(k), "x-amz-storage-class") {
+                                for _, v := range vs {
+                                        h.Add(k, v)
+                                }
+                        }
+                }
+                return h
+        }
+
+        metadata := make(http.Header)
+        metadata.Set("x-amz-storage-class", "REDUCED_REDUNDANCY")
+
+        emptyMetadata := make(http.Header)
+
+        const srcSize = 1024 * 1024
+        buf := bytes.Repeat([]byte("abcde"), srcSize) // gives a buffer of 1MiB
+
+        _, err = c.PutObject(context.Background(), bucketName, "srcObjectRRSClass",
+                bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{StorageClass: "REDUCED_REDUNDANCY"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Get the returned metadata
+        returnedMeta := fetchMeta("srcObjectRRSClass")
+
+        // The response metada should either be equal to metadata (with REDUCED_REDUNDANCY) or emptyMetadata (in case of gateways)
+        if !reflect.DeepEqual(metadata, returnedMeta) && !reflect.DeepEqual(emptyMetadata, returnedMeta) {
+                logError(testName, function, args, startTime, "", "Metadata match failed", err)
+                return
+        }
+
+        metadata = make(http.Header)
+        metadata.Set("x-amz-storage-class", "STANDARD")
+
+        _, err = c.PutObject(context.Background(), bucketName, "srcObjectSSClass",
+                bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{StorageClass: "STANDARD"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+        if reflect.DeepEqual(metadata, fetchMeta("srcObjectSSClass")) {
+                logError(testName, function, args, startTime, "", "Metadata verification failed, STANDARD storage class should not be a part of response metadata", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testStorageClassInvalidMetadataPutObject() {
+        // initialize logging params
+        startTime := time.Now()
+        function := "testStorageClassInvalidMetadataPutObject()"
+        args := map[string]interface{}{}
+        testName := getFuncName()
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err)
+                return
+        }
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test")
+        // Make a new bucket in 'us-east-1' (source bucket).
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        const srcSize = 1024 * 1024
+        buf := bytes.Repeat([]byte("abcde"), srcSize) // gives a buffer of 1MiB
+
+        _, err = c.PutObject(context.Background(), bucketName, "srcObjectRRSClass",
+                bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{StorageClass: "INVALID_STORAGE_CLASS"})
+        if err == nil {
+                logError(testName, function, args, startTime, "", "PutObject with invalid storage class passed, was expected to fail", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+func testStorageClassMetadataCopyObject() {
+        // initialize logging params
+        startTime := time.Now()
+        function := "testStorageClassMetadataCopyObject()"
+        args := map[string]interface{}{}
+        testName := getFuncName()
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO v4 client object creation failed", err)
+                return
+        }
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test")
+        // Make a new bucket in 'us-east-1' (source bucket).
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        fetchMeta := func(object string) (h http.Header) {
+                objInfo, err := c.StatObject(context.Background(), bucketName, object, minio.StatObjectOptions{})
+                args["bucket"] = bucketName
+                args["object"] = object
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "Stat failed", err)
+                        return
+                }
+                h = make(http.Header)
+                for k, vs := range objInfo.Metadata {
+                        if strings.HasPrefix(strings.ToLower(k), "x-amz-storage-class") {
+                                for _, v := range vs {
+                                        h.Add(k, v)
+                                }
+                        }
+                }
+                return h
+        }
+
+        metadata := make(http.Header)
+        metadata.Set("x-amz-storage-class", "REDUCED_REDUNDANCY")
+
+        emptyMetadata := make(http.Header)
+
+        const srcSize = 1024 * 1024
+        buf := bytes.Repeat([]byte("abcde"), srcSize)
+
+        // Put an object with RRS Storage class
+        _, err = c.PutObject(context.Background(), bucketName, "srcObjectRRSClass",
+                bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{StorageClass: "REDUCED_REDUNDANCY"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Make server side copy of object uploaded in previous step
+        src := minio.CopySrcOptions{
+                Bucket: bucketName,
+                Object: "srcObjectRRSClass",
+        }
+        dst := minio.CopyDestOptions{
+                Bucket: bucketName,
+                Object: "srcObjectRRSClassCopy",
+        }
+        if _, err = c.CopyObject(context.Background(), dst, src); err != nil {
+                logError(testName, function, args, startTime, "", "CopyObject failed on RRS", err)
+                return
+        }
+
+        // Get the returned metadata
+        returnedMeta := fetchMeta("srcObjectRRSClassCopy")
+
+        // The response metada should either be equal to metadata (with REDUCED_REDUNDANCY) or emptyMetadata (in case of gateways)
+        if !reflect.DeepEqual(metadata, returnedMeta) && !reflect.DeepEqual(emptyMetadata, returnedMeta) {
+                logError(testName, function, args, startTime, "", "Metadata match failed", err)
+                return
+        }
+
+        metadata = make(http.Header)
+        metadata.Set("x-amz-storage-class", "STANDARD")
+
+        // Put an object with Standard Storage class
+        _, err = c.PutObject(context.Background(), bucketName, "srcObjectSSClass",
+                bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{StorageClass: "STANDARD"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Make server side copy of object uploaded in previous step
+        src = minio.CopySrcOptions{
+                Bucket: bucketName,
+                Object: "srcObjectSSClass",
+        }
+        dst = minio.CopyDestOptions{
+                Bucket: bucketName,
+                Object: "srcObjectSSClassCopy",
+        }
+        if _, err = c.CopyObject(context.Background(), dst, src); err != nil {
+                logError(testName, function, args, startTime, "", "CopyObject failed on SS", err)
+                return
+        }
+        // Fetch the meta data of copied object
+        if reflect.DeepEqual(metadata, fetchMeta("srcObjectSSClassCopy")) {
+                logError(testName, function, args, startTime, "", "Metadata verification failed, STANDARD storage class should not be a part of response metadata", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test put object with size -1 byte object.
+func testPutObjectNoLengthV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(bucketName, objectName, reader, size, opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "size":       -1,
+                "opts":       "",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client v2 object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        objectName := bucketName + "unique"
+        args["objectName"] = objectName
+
+        bufSize := dataFileMap["datafile-129-MB"]
+        reader := getDataReader("datafile-129-MB")
+        defer reader.Close()
+        args["size"] = bufSize
+
+        // Upload an object.
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, -1, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObjectWithSize failed", err)
+                return
+        }
+
+        st, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Expected upload object size "+string(bufSize)+" got "+string(st.Size), err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test put objects of unknown size.
+func testPutObjectsUnknownV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(bucketName, objectName, reader,size,opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "size":       "",
+                "opts":       "",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client v2 object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Issues are revealed by trying to upload multiple files of unknown size
+        // sequentially (on 4GB machines)
+        for i := 1; i <= 4; i++ {
+                // Simulate that we could be receiving byte slices of data that we want
+                // to upload as a file
+                rpipe, wpipe := io.Pipe()
+                defer rpipe.Close()
+                go func() {
+                        b := []byte("test")
+                        wpipe.Write(b)
+                        wpipe.Close()
+                }()
+
+                // Upload the object.
+                objectName := fmt.Sprintf("%sunique%d", bucketName, i)
+                args["objectName"] = objectName
+
+                ui, err := c.PutObject(context.Background(), bucketName, objectName, rpipe, -1, minio.PutObjectOptions{})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "PutObjectStreaming failed", err)
+                        return
+                }
+
+                if ui.Size != 4 {
+                        logError(testName, function, args, startTime, "", "Expected upload object size "+string(4)+" got "+string(ui.Size), nil)
+                        return
+                }
+
+                st, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "StatObjectStreaming failed", err)
+                        return
+                }
+
+                if st.Size != int64(4) {
+                        logError(testName, function, args, startTime, "", "Expected upload object size "+string(4)+" got "+string(st.Size), err)
+                        return
+                }
+
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test put object with 0 byte object.
+func testPutObject0ByteV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(bucketName, objectName, reader, size, opts)"
+        args := map[string]interface{}{
+                "bucketName": "",
+                "objectName": "",
+                "size":       0,
+                "opts":       "",
+        }
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client v2 object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        objectName := bucketName + "unique"
+        args["objectName"] = objectName
+        args["opts"] = minio.PutObjectOptions{}
+
+        // Upload an object.
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader([]byte("")), 0, minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObjectWithSize failed", err)
+                return
+        }
+        st, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObjectWithSize failed", err)
+                return
+        }
+        if st.Size != 0 {
+                logError(testName, function, args, startTime, "", "Expected upload object size 0 but got "+string(st.Size), err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test expected error cases
+func testComposeObjectErrorCases() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "ComposeObject(destination, sourceList)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        testComposeObjectErrorCasesWrapper(c)
+}
+
+// Test concatenating multiple 10K objects V4
+func testCompose10KSources() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "ComposeObject(destination, sourceList)"
+        args := map[string]interface{}{}
+
+        // Instantiate new minio client object
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client object creation failed", err)
+                return
+        }
+
+        testComposeMultipleSources(c)
+}
+
+// Tests comprehensive list of all methods.
+func testFunctionalV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "testFunctionalV2()"
+        functionAll := ""
+        args := map[string]interface{}{}
+
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client v2 object creation failed", err)
+                return
+        }
+
+        // Enable to debug
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        location := "us-east-1"
+        // Make a new bucket.
+        function = "MakeBucket(bucketName, location)"
+        functionAll = "MakeBucket(bucketName, location)"
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "location":   location,
+        }
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: location})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        // Generate a random file name.
+        fileName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        file, err := os.Create(fileName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "file create failed", err)
+                return
+        }
+        for i := 0; i < 3; i++ {
+                buf := make([]byte, rand.Intn(1<<19))
+                _, err = file.Write(buf)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "file write failed", err)
+                        return
+                }
+        }
+        file.Close()
+
+        // Verify if bucket exits and you have access.
+        var exists bool
+        function = "BucketExists(bucketName)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+        }
+        exists, err = c.BucketExists(context.Background(), bucketName)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "BucketExists failed", err)
+                return
+        }
+        if !exists {
+                logError(testName, function, args, startTime, "", "Could not find existing bucket "+bucketName, err)
+                return
+        }
+
+        // Make the bucket 'public read/write'.
+        function = "SetBucketPolicy(bucketName, bucketPolicy)"
+        functionAll += ", " + function
+
+        readWritePolicy := `{"Version": "2012-10-17","Statement": [{"Action": ["s3:ListBucketMultipartUploads", "s3:ListBucket"],"Effect": "Allow","Principal": {"AWS": ["*"]},"Resource": ["arn:aws:s3:::` + bucketName + `"],"Sid": ""}]}`
+
+        args = map[string]interface{}{
+                "bucketName":   bucketName,
+                "bucketPolicy": readWritePolicy,
+        }
+        err = c.SetBucketPolicy(context.Background(), bucketName, readWritePolicy)
+
+        if err != nil {
+                logError(testName, function, args, startTime, "", "SetBucketPolicy failed", err)
+                return
+        }
+
+        // List all buckets.
+        function = "ListBuckets()"
+        functionAll += ", " + function
+        args = nil
+        buckets, err := c.ListBuckets(context.Background())
+        if len(buckets) == 0 {
+                logError(testName, function, args, startTime, "", "List buckets cannot be empty", err)
+                return
+        }
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ListBuckets failed", err)
+                return
+        }
+
+        // Verify if previously created bucket is listed in list buckets.
+        bucketFound := false
+        for _, bucket := range buckets {
+                if bucket.Name == bucketName {
+                        bucketFound = true
+                }
+        }
+
+        // If bucket not found error out.
+        if !bucketFound {
+                logError(testName, function, args, startTime, "", "Bucket "+bucketName+"not found", err)
+                return
+        }
+
+        objectName := bucketName + "unique"
+
+        // Generate data
+        buf := bytes.Repeat([]byte("n"), rand.Intn(1<<19))
+
+        args = map[string]interface{}{
+                "bucketName":  bucketName,
+                "objectName":  objectName,
+                "contentType": "",
+        }
+        _, err = c.PutObject(context.Background(), bucketName, objectName, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        st, err := c.StatObject(context.Background(), bucketName, objectName, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+        if st.Size != int64(len(buf)) {
+                logError(testName, function, args, startTime, "", "Expected uploaded object length "+string(len(buf))+" got "+string(st.Size), err)
+                return
+        }
+
+        objectNameNoLength := objectName + "-nolength"
+        args["objectName"] = objectNameNoLength
+        _, err = c.PutObject(context.Background(), bucketName, objectNameNoLength, bytes.NewReader(buf), int64(len(buf)), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+        st, err = c.StatObject(context.Background(), bucketName, objectNameNoLength, minio.StatObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "StatObject failed", err)
+                return
+        }
+        if st.Size != int64(len(buf)) {
+                logError(testName, function, args, startTime, "", "Expected uploaded object length "+string(len(buf))+" got "+string(st.Size), err)
+                return
+        }
+
+        // Instantiate a done channel to close all listing.
+        doneCh := make(chan struct{})
+        defer close(doneCh)
+
+        objFound := false
+        isRecursive := true // Recursive is true.
+        function = "ListObjects(bucketName, objectName, isRecursive, doneCh)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName":  bucketName,
+                "objectName":  objectName,
+                "isRecursive": isRecursive,
+        }
+        for obj := range c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{UseV1: true, Prefix: objectName, Recursive: isRecursive}) {
+                if obj.Key == objectName {
+                        objFound = true
+                        break
+                }
+        }
+        if !objFound {
+                logError(testName, function, args, startTime, "", "Could not find existing object "+objectName, err)
+                return
+        }
+
+        incompObjNotFound := true
+        function = "ListIncompleteUploads(bucketName, objectName, isRecursive, doneCh)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName":  bucketName,
+                "objectName":  objectName,
+                "isRecursive": isRecursive,
+        }
+        for objIncompl := range c.ListIncompleteUploads(context.Background(), bucketName, objectName, isRecursive) {
+                if objIncompl.Key != "" {
+                        incompObjNotFound = false
+                        break
+                }
+        }
+        if !incompObjNotFound {
+                logError(testName, function, args, startTime, "", "Unexpected dangling incomplete upload found", err)
+                return
+        }
+
+        function = "GetObject(bucketName, objectName)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": objectName,
+        }
+        newReader, err := c.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+
+        newReadBytes, err := io.ReadAll(newReader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+        newReader.Close()
+
+        if !bytes.Equal(newReadBytes, buf) {
+                logError(testName, function, args, startTime, "", "Bytes mismatch", err)
+                return
+        }
+
+        function = "FGetObject(bucketName, objectName, fileName)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": objectName,
+                "fileName":   fileName + "-f",
+        }
+        err = c.FGetObject(context.Background(), bucketName, objectName, fileName+"-f", minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "FgetObject failed", err)
+                return
+        }
+
+        // Generate presigned HEAD object url.
+        function = "PresignedHeadObject(bucketName, objectName, expires, reqParams)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": objectName,
+                "expires":    3600 * time.Second,
+        }
+        presignedHeadURL, err := c.PresignedHeadObject(context.Background(), bucketName, objectName, 3600*time.Second, nil)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedHeadObject failed", err)
+                return
+        }
+
+        transport, err := minio.DefaultTransport(mustParseBool(os.Getenv(enableHTTPS)))
+        if err != nil {
+                logError(testName, function, args, startTime, "", "DefaultTransport failed", err)
+                return
+        }
+
+        httpClient := &http.Client{
+                // Setting a sensible time out of 30secs to wait for response
+                // headers. Request is pro-actively canceled after 30secs
+                // with no response.
+                Timeout:   30 * time.Second,
+                Transport: transport,
+        }
+
+        req, err := http.NewRequest(http.MethodHead, presignedHeadURL.String(), nil)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedHeadObject URL head request failed", err)
+                return
+        }
+
+        // Verify if presigned url works.
+        resp, err := httpClient.Do(req)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedHeadObject URL head request failed", err)
+                return
+        }
+        if resp.StatusCode != http.StatusOK {
+                logError(testName, function, args, startTime, "", "PresignedHeadObject URL returns status "+string(resp.StatusCode), err)
+                return
+        }
+        if resp.Header.Get("ETag") == "" {
+                logError(testName, function, args, startTime, "", "Got empty ETag", err)
+                return
+        }
+        resp.Body.Close()
+
+        // Generate presigned GET object url.
+        function = "PresignedGetObject(bucketName, objectName, expires, reqParams)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": objectName,
+                "expires":    3600 * time.Second,
+        }
+        presignedGetURL, err := c.PresignedGetObject(context.Background(), bucketName, objectName, 3600*time.Second, nil)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject failed", err)
+                return
+        }
+
+        // Verify if presigned url works.
+        req, err = http.NewRequest(http.MethodGet, presignedGetURL.String(), nil)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject request incorrect", err)
+                return
+        }
+
+        resp, err = httpClient.Do(req)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject response incorrect", err)
+                return
+        }
+
+        if resp.StatusCode != http.StatusOK {
+                logError(testName, function, args, startTime, "", "PresignedGetObject URL returns status "+string(resp.StatusCode), err)
+                return
+        }
+        newPresignedBytes, err := io.ReadAll(resp.Body)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+        resp.Body.Close()
+        if !bytes.Equal(newPresignedBytes, buf) {
+                logError(testName, function, args, startTime, "", "Bytes mismatch", err)
+                return
+        }
+
+        // Set request parameters.
+        reqParams := make(url.Values)
+        reqParams.Set("response-content-disposition", "attachment; filename=\"test.txt\"")
+        // Generate presigned GET object url.
+        args["reqParams"] = reqParams
+        presignedGetURL, err = c.PresignedGetObject(context.Background(), bucketName, objectName, 3600*time.Second, reqParams)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject failed", err)
+                return
+        }
+
+        // Verify if presigned url works.
+        req, err = http.NewRequest(http.MethodGet, presignedGetURL.String(), nil)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject request incorrect", err)
+                return
+        }
+
+        resp, err = httpClient.Do(req)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedGetObject response incorrect", err)
+                return
+        }
+
+        if resp.StatusCode != http.StatusOK {
+                logError(testName, function, args, startTime, "", "PresignedGetObject URL returns status "+string(resp.StatusCode), err)
+                return
+        }
+        newPresignedBytes, err = io.ReadAll(resp.Body)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed", err)
+                return
+        }
+        if !bytes.Equal(newPresignedBytes, buf) {
+                logError(testName, function, args, startTime, "", "Bytes mismatch", err)
+                return
+        }
+        // Verify content disposition.
+        if resp.Header.Get("Content-Disposition") != "attachment; filename=\"test.txt\"" {
+                logError(testName, function, args, startTime, "", "wrong Content-Disposition received ", err)
+                return
+        }
+
+        function = "PresignedPutObject(bucketName, objectName, expires)"
+        functionAll += ", " + function
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": objectName + "-presigned",
+                "expires":    3600 * time.Second,
+        }
+        presignedPutURL, err := c.PresignedPutObject(context.Background(), bucketName, objectName+"-presigned", 3600*time.Second)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PresignedPutObject failed", err)
+                return
+        }
+
+        // Generate data more than 32K
+        buf = bytes.Repeat([]byte("1"), rand.Intn(1<<10)+32*1024)
+
+        req, err = http.NewRequest(http.MethodPut, presignedPutURL.String(), bytes.NewReader(buf))
+        if err != nil {
+                logError(testName, function, args, startTime, "", "HTTP request to PresignedPutObject URL failed", err)
+                return
+        }
+
+        resp, err = httpClient.Do(req)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "HTTP request to PresignedPutObject URL failed", err)
+                return
+        }
+
+        // Download the uploaded object to verify
+        args = map[string]interface{}{
+                "bucketName": bucketName,
+                "objectName": objectName + "-presigned",
+        }
+        newReader, err = c.GetObject(context.Background(), bucketName, objectName+"-presigned", minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject of uploaded presigned object failed", err)
+                return
+        }
+
+        newReadBytes, err = io.ReadAll(newReader)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "ReadAll failed during get on presigned put object", err)
+                return
+        }
+        newReader.Close()
+
+        if !bytes.Equal(newReadBytes, buf) {
+                logError(testName, function, args, startTime, "", "Bytes mismatch on presigned object upload verification", err)
+                return
+        }
+
+        function = "PresignHeader(method, bucketName, objectName, expires, reqParams, extraHeaders)"
+        functionAll += ", " + function
+        presignExtraHeaders := map[string][]string{
+                "mysecret": {"abcxxx"},
+        }
+        args = map[string]interface{}{
+                "method":       "PUT",
+                "bucketName":   bucketName,
+                "objectName":   objectName + "-presign-custom",
+                "expires":      3600 * time.Second,
+                "extraHeaders": presignExtraHeaders,
+        }
+        _, err = c.PresignHeader(context.Background(), "PUT", bucketName, objectName+"-presign-custom", 3600*time.Second, nil, presignExtraHeaders)
+        if err == nil {
+                logError(testName, function, args, startTime, "", "Presigned with extra headers succeeded", err)
+                return
+        }
+
+        os.Remove(fileName)
+        os.Remove(fileName + "-f")
+        successLogger(testName, functionAll, args, startTime).Info()
+}
+
+// Test get object with GetObject with context
+func testGetObjectContext() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(ctx, bucketName, objectName)"
+        args := map[string]interface{}{
+                "ctx":        "",
+                "bucketName": "",
+                "objectName": "",
+        }
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client v4 object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        bufSize := dataFileMap["datafile-33-kB"]
+        reader := getDataReader("datafile-33-kB")
+        defer reader.Close()
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        ctx, cancel := context.WithTimeout(context.Background(), 1*time.Nanosecond)
+        args["ctx"] = ctx
+        cancel()
+
+        r, err := c.GetObject(ctx, bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed unexpectedly", err)
+                return
+        }
+
+        if _, err = r.Stat(); err == nil {
+                logError(testName, function, args, startTime, "", "GetObject should fail on short timeout", err)
+                return
+        }
+        r.Close()
+
+        ctx, cancel = context.WithTimeout(context.Background(), 1*time.Hour)
+        args["ctx"] = ctx
+        defer cancel()
+
+        // Read the data back
+        r, err = c.GetObject(ctx, bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed", err)
+                return
+        }
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "object Stat call failed", err)
+                return
+        }
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes in stat does not match: want "+string(bufSize)+", got"+string(st.Size), err)
+                return
+        }
+        if err := r.Close(); err != nil {
+                logError(testName, function, args, startTime, "", "object Close() call failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test get object with FGetObject with a user provided context
+func testFGetObjectContext() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "FGetObject(ctx, bucketName, objectName, fileName)"
+        args := map[string]interface{}{
+                "ctx":        "",
+                "bucketName": "",
+                "objectName": "",
+                "fileName":   "",
+        }
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client v4 object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        bufSize := dataFileMap["datafile-1-MB"]
+        reader := getDataReader("datafile-1-MB")
+        defer reader.Close()
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        ctx, cancel := context.WithTimeout(context.Background(), 1*time.Nanosecond)
+        args["ctx"] = ctx
+        defer cancel()
+
+        fileName := "tempfile-context"
+        args["fileName"] = fileName
+        // Read the data back
+        err = c.FGetObject(ctx, bucketName, objectName, fileName+"-f", minio.GetObjectOptions{})
+        if err == nil {
+                logError(testName, function, args, startTime, "", "FGetObject should fail on short timeout", err)
+                return
+        }
+        ctx, cancel = context.WithTimeout(context.Background(), 1*time.Hour)
+        defer cancel()
+
+        // Read the data back
+        err = c.FGetObject(ctx, bucketName, objectName, fileName+"-fcontext", minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "FGetObject with long timeout failed", err)
+                return
+        }
+        if err = os.Remove(fileName + "-fcontext"); err != nil {
+                logError(testName, function, args, startTime, "", "Remove file failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test get object with GetObject with a user provided context
+func testGetObjectRanges() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(ctx, bucketName, objectName, fileName)"
+        args := map[string]interface{}{
+                "ctx":        "",
+                "bucketName": "",
+                "objectName": "",
+                "fileName":   "",
+        }
+        ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+        defer cancel()
+
+        rng := rand.NewSource(time.Now().UnixNano())
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client v4 object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rng, "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        bufSize := dataFileMap["datafile-129-MB"]
+        reader := getDataReader("datafile-129-MB")
+        defer reader.Close()
+        // Save the data
+        objectName := randString(60, rng, "")
+        args["objectName"] = objectName
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        // Read the data back
+        tests := []struct {
+                start int64
+                end   int64
+        }{
+                {
+                        start: 1024,
+                        end:   1024 + 1<<20,
+                },
+                {
+                        start: 20e6,
+                        end:   20e6 + 10000,
+                },
+                {
+                        start: 40e6,
+                        end:   40e6 + 10000,
+                },
+                {
+                        start: 60e6,
+                        end:   60e6 + 10000,
+                },
+                {
+                        start: 80e6,
+                        end:   80e6 + 10000,
+                },
+                {
+                        start: 120e6,
+                        end:   int64(bufSize),
+                },
+        }
+        for _, test := range tests {
+                wantRC := getDataReader("datafile-129-MB")
+                io.CopyN(io.Discard, wantRC, test.start)
+                want := mustCrcReader(io.LimitReader(wantRC, test.end-test.start+1))
+                opts := minio.GetObjectOptions{}
+                opts.SetRange(test.start, test.end)
+                args["opts"] = fmt.Sprintf("%+v", test)
+                obj, err := c.GetObject(ctx, bucketName, objectName, opts)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", "FGetObject with long timeout failed", err)
+                        return
+                }
+                err = crcMatches(obj, want)
+                if err != nil {
+                        logError(testName, function, args, startTime, "", fmt.Sprintf("GetObject offset %d -> %d", test.start, test.end), err)
+                        return
+                }
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test get object ACLs with GetObjectACL with custom provided context
+func testGetObjectACLContext() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObjectACL(ctx, bucketName, objectName)"
+        args := map[string]interface{}{
+                "ctx":        "",
+                "bucketName": "",
+                "objectName": "",
+        }
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client v4 object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        bufSize := dataFileMap["datafile-1-MB"]
+        reader := getDataReader("datafile-1-MB")
+        defer reader.Close()
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        // Add meta data to add a canned acl
+        metaData := map[string]string{
+                "X-Amz-Acl": "public-read-write",
+        }
+
+        _, err = c.PutObject(context.Background(), bucketName,
+                objectName, reader, int64(bufSize),
+                minio.PutObjectOptions{
+                        ContentType:  "binary/octet-stream",
+                        UserMetadata: metaData,
+                })
+
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+        args["ctx"] = ctx
+        defer cancel()
+
+        // Read the data back
+        objectInfo, getObjectACLErr := c.GetObjectACL(ctx, bucketName, objectName)
+        if getObjectACLErr != nil {
+                logError(testName, function, args, startTime, "", "GetObjectACL failed. ", getObjectACLErr)
+                return
+        }
+
+        s, ok := objectInfo.Metadata["X-Amz-Acl"]
+        if !ok {
+                logError(testName, function, args, startTime, "", "GetObjectACL fail unable to find \"X-Amz-Acl\"", nil)
+                return
+        }
+
+        if len(s) != 1 {
+                logError(testName, function, args, startTime, "", "GetObjectACL fail \"X-Amz-Acl\" canned acl expected \"1\" got "+fmt.Sprintf(`"%d"`, len(s)), nil)
+                return
+        }
+
+        // Do a very limited testing if this is not AWS S3
+        if os.Getenv(serverEndpoint) != "s3.amazonaws.com" {
+                if s[0] != "private" {
+                        logError(testName, function, args, startTime, "", "GetObjectACL fail \"X-Amz-Acl\" expected \"private\" but got"+fmt.Sprintf("%q", s[0]), nil)
+                        return
+                }
+
+                successLogger(testName, function, args, startTime).Info()
+                return
+        }
+
+        if s[0] != "public-read-write" {
+                logError(testName, function, args, startTime, "", "GetObjectACL fail \"X-Amz-Acl\" expected \"public-read-write\" but got"+fmt.Sprintf("%q", s[0]), nil)
+                return
+        }
+
+        bufSize = dataFileMap["datafile-1-MB"]
+        reader2 := getDataReader("datafile-1-MB")
+        defer reader2.Close()
+        // Save the data
+        objectName = randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        // Add meta data to add a canned acl
+        metaData = map[string]string{
+                "X-Amz-Grant-Read":  "[email protected]",
+                "X-Amz-Grant-Write": "[email protected]",
+        }
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader2, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream", UserMetadata: metaData})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject failed", err)
+                return
+        }
+
+        ctx, cancel = context.WithTimeout(context.Background(), 10*time.Second)
+        args["ctx"] = ctx
+        defer cancel()
+
+        // Read the data back
+        objectInfo, getObjectACLErr = c.GetObjectACL(ctx, bucketName, objectName)
+        if getObjectACLErr == nil {
+                logError(testName, function, args, startTime, "", "GetObjectACL fail", getObjectACLErr)
+                return
+        }
+
+        if len(objectInfo.Metadata) != 3 {
+                logError(testName, function, args, startTime, "", "GetObjectACL fail expected \"3\" ACLs but got "+fmt.Sprintf(`"%d"`, len(objectInfo.Metadata)), nil)
+                return
+        }
+
+        s, ok = objectInfo.Metadata["X-Amz-Grant-Read"]
+        if !ok {
+                logError(testName, function, args, startTime, "", "GetObjectACL fail unable to find \"X-Amz-Grant-Read\"", nil)
+                return
+        }
+
+        if len(s) != 1 {
+                logError(testName, function, args, startTime, "", "GetObjectACL fail \"X-Amz-Grant-Read\" acl expected \"1\" got "+fmt.Sprintf(`"%d"`, len(s)), nil)
+                return
+        }
+
+        if s[0] != "[email protected]" {
+                logError(testName, function, args, startTime, "", "GetObjectACL fail \"X-Amz-Grant-Read\" acl expected \"[email protected]\" got "+fmt.Sprintf("%q", s), nil)
+                return
+        }
+
+        s, ok = objectInfo.Metadata["X-Amz-Grant-Write"]
+        if !ok {
+                logError(testName, function, args, startTime, "", "GetObjectACL fail unable to find \"X-Amz-Grant-Write\"", nil)
+                return
+        }
+
+        if len(s) != 1 {
+                logError(testName, function, args, startTime, "", "GetObjectACL fail \"X-Amz-Grant-Write\" acl expected \"1\" got "+fmt.Sprintf(`"%d"`, len(s)), nil)
+                return
+        }
+
+        if s[0] != "[email protected]" {
+                logError(testName, function, args, startTime, "", "GetObjectACL fail \"X-Amz-Grant-Write\" acl expected \"[email protected]\" got "+fmt.Sprintf("%q", s), nil)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test validates putObject with context to see if request cancellation is honored for V2.
+func testPutObjectContextV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "PutObject(ctx, bucketName, objectName, reader, size, opts)"
+        args := map[string]interface{}{
+                "ctx":        "",
+                "bucketName": "",
+                "objectName": "",
+                "size":       "",
+                "opts":       "",
+        }
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client v2 object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Make a new bucket.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+        defer cleanupBucket(bucketName, c)
+        bufSize := dataFileMap["datatfile-33-kB"]
+        reader := getDataReader("datafile-33-kB")
+        defer reader.Close()
+
+        objectName := fmt.Sprintf("test-file-%v", rand.Uint32())
+        args["objectName"] = objectName
+
+        ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+        args["ctx"] = ctx
+        args["size"] = bufSize
+        defer cancel()
+
+        _, err = c.PutObject(ctx, bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject with short timeout failed", err)
+                return
+        }
+
+        ctx, cancel = context.WithTimeout(context.Background(), 1*time.Hour)
+        args["ctx"] = ctx
+
+        defer cancel()
+        reader = getDataReader("datafile-33-kB")
+        defer reader.Close()
+        _, err = c.PutObject(ctx, bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject with long timeout failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test get object with GetObject with custom context
+func testGetObjectContextV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "GetObject(ctx, bucketName, objectName)"
+        args := map[string]interface{}{
+                "ctx":        "",
+                "bucketName": "",
+                "objectName": "",
+        }
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client v2 object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        bufSize := dataFileMap["datafile-33-kB"]
+        reader := getDataReader("datafile-33-kB")
+        defer reader.Close()
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject call failed", err)
+                return
+        }
+
+        ctx, cancel := context.WithTimeout(context.Background(), 1*time.Nanosecond)
+        args["ctx"] = ctx
+        cancel()
+
+        r, err := c.GetObject(ctx, bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject failed unexpectedly", err)
+                return
+        }
+        if _, err = r.Stat(); err == nil {
+                logError(testName, function, args, startTime, "", "GetObject should fail on short timeout", err)
+                return
+        }
+        r.Close()
+
+        ctx, cancel = context.WithTimeout(context.Background(), 1*time.Hour)
+        defer cancel()
+
+        // Read the data back
+        r, err = c.GetObject(ctx, bucketName, objectName, minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "GetObject shouldn't fail on longer timeout", err)
+                return
+        }
+
+        st, err := r.Stat()
+        if err != nil {
+                logError(testName, function, args, startTime, "", "object Stat call failed", err)
+                return
+        }
+        if st.Size != int64(bufSize) {
+                logError(testName, function, args, startTime, "", "Number of bytes in stat does not match, expected "+string(bufSize)+" got "+string(st.Size), err)
+                return
+        }
+        if err := r.Close(); err != nil {
+                logError(testName, function, args, startTime, "", " object Close() call failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test get object with FGetObject with custom context
+func testFGetObjectContextV2() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "FGetObject(ctx, bucketName, objectName,fileName)"
+        args := map[string]interface{}{
+                "ctx":        "",
+                "bucketName": "",
+                "objectName": "",
+                "fileName":   "",
+        }
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV2(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client v2 object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket call failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        bufSize := dataFileMap["datatfile-1-MB"]
+        reader := getDataReader("datafile-1-MB")
+        defer reader.Close()
+        // Save the data
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{ContentType: "binary/octet-stream"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "PutObject call failed", err)
+                return
+        }
+
+        ctx, cancel := context.WithTimeout(context.Background(), 1*time.Nanosecond)
+        args["ctx"] = ctx
+        defer cancel()
+
+        fileName := "tempfile-context"
+        args["fileName"] = fileName
+
+        // Read the data back
+        err = c.FGetObject(ctx, bucketName, objectName, fileName+"-f", minio.GetObjectOptions{})
+        if err == nil {
+                logError(testName, function, args, startTime, "", "FGetObject should fail on short timeout", err)
+                return
+        }
+        ctx, cancel = context.WithTimeout(context.Background(), 1*time.Hour)
+        defer cancel()
+
+        // Read the data back
+        err = c.FGetObject(ctx, bucketName, objectName, fileName+"-fcontext", minio.GetObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "FGetObject call shouldn't fail on long timeout", err)
+                return
+        }
+
+        if err = os.Remove(fileName + "-fcontext"); err != nil {
+                logError(testName, function, args, startTime, "", "Remove file failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test list object v1 and V2
+func testListObjects() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "ListObjects(bucketName, objectPrefix, recursive, doneCh)"
+        args := map[string]interface{}{
+                "bucketName":   "",
+                "objectPrefix": "",
+                "recursive":    "true",
+        }
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client v4 object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1"})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        defer cleanupBucket(bucketName, c)
+
+        testObjects := []struct {
+                name         string
+                storageClass string
+        }{
+                // Special characters
+                {"foo bar", "STANDARD"},
+                {"foo-%", "STANDARD"},
+                {"random-object-1", "STANDARD"},
+                {"random-object-2", "REDUCED_REDUNDANCY"},
+        }
+
+        for i, object := range testObjects {
+                bufSize := dataFileMap["datafile-33-kB"]
+                reader := getDataReader("datafile-33-kB")
+                defer reader.Close()
+                _, err = c.PutObject(context.Background(), bucketName, object.name, reader, int64(bufSize),
+                        minio.PutObjectOptions{ContentType: "binary/octet-stream", StorageClass: object.storageClass})
+                if err != nil {
+                        logError(testName, function, args, startTime, "", fmt.Sprintf("PutObject %d call failed", i+1), err)
+                        return
+                }
+        }
+
+        testList := func(listFn func(context.Context, string, minio.ListObjectsOptions) <-chan minio.ObjectInfo, bucket string, opts minio.ListObjectsOptions) {
+                var objCursor int
+
+                // check for object name and storage-class from listing object result
+                for objInfo := range listFn(context.Background(), bucket, opts) {
+                        if objInfo.Err != nil {
+                                logError(testName, function, args, startTime, "", "ListObjects failed unexpectedly", err)
+                                return
+                        }
+                        if objInfo.Key != testObjects[objCursor].name {
+                                logError(testName, function, args, startTime, "", "ListObjects does not return expected object name", err)
+                                return
+                        }
+                        if objInfo.StorageClass != testObjects[objCursor].storageClass {
+                                // Ignored as Gateways (Azure/GCS etc) wont return storage class
+                                ignoredLog(testName, function, args, startTime, "ListObjects doesn't return expected storage class").Info()
+                        }
+                        objCursor++
+                }
+
+                if objCursor != len(testObjects) {
+                        logError(testName, function, args, startTime, "", "ListObjects returned unexpected number of items", errors.New(""))
+                        return
+                }
+        }
+
+        testList(c.ListObjects, bucketName, minio.ListObjectsOptions{Recursive: true, UseV1: true})
+        testList(c.ListObjects, bucketName, minio.ListObjectsOptions{Recursive: true})
+        testList(c.ListObjects, bucketName, minio.ListObjectsOptions{Recursive: true, WithMetadata: true})
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Test deleting multiple objects with object retention set in Governance mode
+func testRemoveObjects() {
+        // initialize logging params
+        startTime := time.Now()
+        testName := getFuncName()
+        function := "RemoveObjects(bucketName, objectsCh, opts)"
+        args := map[string]interface{}{
+                "bucketName":   "",
+                "objectPrefix": "",
+                "recursive":    "true",
+        }
+        // Seed random based on current time.
+        rand.Seed(time.Now().Unix())
+
+        // Instantiate new minio client object.
+        c, err := minio.New(os.Getenv(serverEndpoint),
+                &minio.Options{
+                        Creds:  credentials.NewStaticV4(os.Getenv(accessKey), os.Getenv(secretKey), ""),
+                        Secure: mustParseBool(os.Getenv(enableHTTPS)),
+                })
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MinIO client v4 object creation failed", err)
+                return
+        }
+
+        // Enable tracing, write to stderr.
+        // c.TraceOn(os.Stderr)
+
+        // Set user agent.
+        c.SetAppInfo("MinIO-go-FunctionalTest", "0.1.0")
+
+        // Generate a new random bucket name.
+        bucketName := randString(60, rand.NewSource(time.Now().UnixNano()), "minio-go-test-")
+        args["bucketName"] = bucketName
+        objectName := randString(60, rand.NewSource(time.Now().UnixNano()), "")
+        args["objectName"] = objectName
+
+        // Make a new bucket.
+        err = c.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: true})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "MakeBucket failed", err)
+                return
+        }
+
+        bufSize := dataFileMap["datafile-129-MB"]
+        reader := getDataReader("datafile-129-MB")
+        defer reader.Close()
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Error uploading object", err)
+                return
+        }
+
+        // Replace with smaller...
+        bufSize = dataFileMap["datafile-10-kB"]
+        reader = getDataReader("datafile-10-kB")
+        defer reader.Close()
+
+        _, err = c.PutObject(context.Background(), bucketName, objectName, reader, int64(bufSize), minio.PutObjectOptions{})
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Error uploading object", err)
+        }
+
+        t := time.Date(2030, time.April, 25, 14, 0, 0, 0, time.UTC)
+        m := minio.RetentionMode(minio.Governance)
+        opts := minio.PutObjectRetentionOptions{
+                GovernanceBypass: false,
+                RetainUntilDate:  &t,
+                Mode:             &m,
+        }
+        err = c.PutObjectRetention(context.Background(), bucketName, objectName, opts)
+        if err != nil {
+                logError(testName, function, args, startTime, "", "Error setting retention", err)
+                return
+        }
+
+        objectsCh := make(chan minio.ObjectInfo)
+        // Send object names that are needed to be removed to objectsCh
+        go func() {
+                defer close(objectsCh)
+                // List all objects from a bucket-name with a matching prefix.
+                for object := range c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{UseV1: true, Recursive: true}) {
+                        if object.Err != nil {
+                                logError(testName, function, args, startTime, "", "Error listing objects", object.Err)
+                                return
+                        }
+                        objectsCh <- object
+                }
+        }()
+
+        for rErr := range c.RemoveObjects(context.Background(), bucketName, objectsCh, minio.RemoveObjectsOptions{}) {
+                // Error is expected here because Retention is set on the object
+                // and RemoveObjects is called without Bypass Governance
+                if rErr.Err == nil {
+                        logError(testName, function, args, startTime, "", "Expected error during deletion", nil)
+                        return
+                }
+        }
+
+        objectsCh1 := make(chan minio.ObjectInfo)
+
+        // Send object names that are needed to be removed to objectsCh
+        go func() {
+                defer close(objectsCh1)
+                // List all objects from a bucket-name with a matching prefix.
+                for object := range c.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{UseV1: true, Recursive: true}) {
+                        if object.Err != nil {
+                                logError(testName, function, args, startTime, "", "Error listing objects", object.Err)
+                                return
+                        }
+                        objectsCh1 <- object
+                }
+        }()
+
+        opts1 := minio.RemoveObjectsOptions{
+                GovernanceBypass: true,
+        }
+
+        for rErr := range c.RemoveObjects(context.Background(), bucketName, objectsCh1, opts1) {
+                // Error is not expected here because Retention is set on the object
+                // and RemoveObjects is called with Bypass Governance
+                logError(testName, function, args, startTime, "", "Error detected during deletion", rErr.Err)
+                return
+        }
+
+        // Delete all objects and buckets
+        if err = cleanupVersionedBucket(bucketName, c); err != nil {
+                logError(testName, function, args, startTime, "", "CleanupBucket failed", err)
+                return
+        }
+
+        successLogger(testName, function, args, startTime).Info()
+}
+
+// Convert string to bool and always return false if any error
+func mustParseBool(str string) bool {
+        b, err := strconv.ParseBool(str)
+        if err != nil {
+                return false
+        }
+        return b
+}
+
+func main() {
+        // Output to stdout instead of the default stderr
+        log.SetOutput(os.Stdout)
+        // create custom formatter
+        mintFormatter := mintJSONFormatter{}
+        // set custom formatter
+        log.SetFormatter(&mintFormatter)
+        // log Info or above -- success cases are Info level, failures are Fatal level
+        log.SetLevel(log.InfoLevel)
+
+        tls := mustParseBool(os.Getenv(enableHTTPS))
+        kms := mustParseBool(os.Getenv(enableKMS))
+        if os.Getenv(enableKMS) == "" {
+                // Default to KMS tests.
+                kms = true
+        }
+
+        // execute tests
+        if isFullMode() {
+                testMakeBucketErrorV2()
+                testGetObjectClosedTwiceV2()
+                testFPutObjectV2()
+                testMakeBucketRegionsV2()
+                testGetObjectReadSeekFunctionalV2()
+                testGetObjectReadAtFunctionalV2()
+                testGetObjectRanges()
+                testCopyObjectV2()
+                testFunctionalV2()
+                testComposeObjectErrorCasesV2()
+                testCompose10KSourcesV2()
+                testUserMetadataCopyingV2()
+                testPutObjectWithChecksums()
+                testPutMultipartObjectWithChecksums()
+                testPutObject0ByteV2()
+                testPutObjectNoLengthV2()
+                testPutObjectsUnknownV2()
+                testGetObjectContextV2()
+                testFPutObjectContextV2()
+                testFGetObjectContextV2()
+                testPutObjectContextV2()
+                testPutObjectWithVersioning()
+                testMakeBucketError()
+                testMakeBucketRegions()
+                testPutObjectWithMetadata()
+                testPutObjectReadAt()
+                testPutObjectStreaming()
+                testGetObjectSeekEnd()
+                testGetObjectClosedTwice()
+                testGetObjectS3Zip()
+                testRemoveMultipleObjects()
+                testRemoveMultipleObjectsWithResult()
+                testFPutObjectMultipart()
+                testFPutObject()
+                testGetObjectReadSeekFunctional()
+                testGetObjectReadAtFunctional()
+                testGetObjectReadAtWhenEOFWasReached()
+                testPresignedPostPolicy()
+                testCopyObject()
+                testComposeObjectErrorCases()
+                testCompose10KSources()
+                testUserMetadataCopying()
+                testBucketNotification()
+                testFunctional()
+                testGetObjectModified()
+                testPutObjectUploadSeekedObject()
+                testGetObjectContext()
+                testFPutObjectContext()
+                testFGetObjectContext()
+                testGetObjectACLContext()
+                testPutObjectContext()
+                testStorageClassMetadataPutObject()
+                testStorageClassInvalidMetadataPutObject()
+                testStorageClassMetadataCopyObject()
+                testPutObjectWithContentLanguage()
+                testListObjects()
+                testRemoveObjects()
+                testListObjectVersions()
+                testStatObjectWithVersioning()
+                testGetObjectWithVersioning()
+                testCopyObjectWithVersioning()
+                testConcurrentCopyObjectWithVersioning()
+                testComposeObjectWithVersioning()
+                testRemoveObjectWithVersioning()
+                testRemoveObjectsWithVersioning()
+                testObjectTaggingWithVersioning()
+                testTrailingChecksums()
+                testPutObjectWithAutomaticChecksums()
+
+                // SSE-C tests will only work over TLS connection.
+                if tls {
+                        testSSECEncryptionPutGet()
+                        testSSECEncryptionFPut()
+                        testSSECEncryptedGetObjectReadAtFunctional()
+                        testSSECEncryptedGetObjectReadSeekFunctional()
+                        testEncryptedCopyObjectV2()
+                        testEncryptedSSECToSSECCopyObject()
+                        testEncryptedSSECToUnencryptedCopyObject()
+                        testUnencryptedToSSECCopyObject()
+                        testUnencryptedToUnencryptedCopyObject()
+                        testEncryptedEmptyObject()
+                        testDecryptedCopyObject()
+                        testSSECEncryptedToSSECCopyObjectPart()
+                        testSSECMultipartEncryptedToSSECCopyObjectPart()
+                        testSSECEncryptedToUnencryptedCopyPart()
+                        testUnencryptedToSSECCopyObjectPart()
+                        testUnencryptedToUnencryptedCopyPart()
+                        testEncryptedSSECToSSES3CopyObject()
+                        testEncryptedSSES3ToSSECCopyObject()
+                        testSSECEncryptedToSSES3CopyObjectPart()
+                        testSSES3EncryptedToSSECCopyObjectPart()
+                }
+
+                // KMS tests
+                if kms {
+                        testSSES3EncryptionPutGet()
+                        testSSES3EncryptionFPut()
+                        testSSES3EncryptedGetObjectReadAtFunctional()
+                        testSSES3EncryptedGetObjectReadSeekFunctional()
+                        testEncryptedSSES3ToSSES3CopyObject()
+                        testEncryptedSSES3ToUnencryptedCopyObject()
+                        testUnencryptedToSSES3CopyObject()
+                        testUnencryptedToSSES3CopyObjectPart()
+                        testSSES3EncryptedToUnencryptedCopyPart()
+                        testSSES3EncryptedToSSES3CopyObjectPart()
+                }
+        } else {
+                testFunctional()
+                testFunctionalV2()
+        }
+}
diff --git a/vendor/github.com/minio/minio-go/v7/hook-reader.go b/vendor/github.com/minio/minio-go/v7/hook-reader.go
new file mode 100644
index 0000000..07bc7db
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/hook-reader.go
@@ -0,0 +1,101 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 minio
+
+import (
+        "fmt"
+        "io"
+        "sync"
+)
+
+// hookReader hooks additional reader in the source stream. It is
+// useful for making progress bars. Second reader is appropriately
+// notified about the exact number of bytes read from the primary
+// source on each Read operation.
+type hookReader struct {
+        mu     sync.RWMutex
+        source io.Reader
+        hook   io.Reader
+}
+
+// Seek implements io.Seeker. Seeks source first, and if necessary
+// seeks hook if Seek method is appropriately found.
+func (hr *hookReader) Seek(offset int64, whence int) (n int64, err error) {
+        hr.mu.Lock()
+        defer hr.mu.Unlock()
+
+        // Verify for source has embedded Seeker, use it.
+        sourceSeeker, ok := hr.source.(io.Seeker)
+        if ok {
+                n, err = sourceSeeker.Seek(offset, whence)
+                if err != nil {
+                        return 0, err
+                }
+        }
+
+        if hr.hook != nil {
+                // Verify if hook has embedded Seeker, use it.
+                hookSeeker, ok := hr.hook.(io.Seeker)
+                if ok {
+                        var m int64
+                        m, err = hookSeeker.Seek(offset, whence)
+                        if err != nil {
+                                return 0, err
+                        }
+                        if n != m {
+                                return 0, fmt.Errorf("hook seeker seeked %d bytes, expected source %d bytes", m, n)
+                        }
+                }
+        }
+
+        return n, nil
+}
+
+// Read implements io.Reader. Always reads from the source, the return
+// value 'n' number of bytes are reported through the hook. Returns
+// error for all non io.EOF conditions.
+func (hr *hookReader) Read(b []byte) (n int, err error) {
+        hr.mu.RLock()
+        defer hr.mu.RUnlock()
+
+        n, err = hr.source.Read(b)
+        if err != nil && err != io.EOF {
+                return n, err
+        }
+        if hr.hook != nil {
+                // Progress the hook with the total read bytes from the source.
+                if _, herr := hr.hook.Read(b[:n]); herr != nil {
+                        if herr != io.EOF {
+                                return n, herr
+                        }
+                }
+        }
+        return n, err
+}
+
+// newHook returns a io.ReadSeeker which implements hookReader that
+// reports the data read from the source to the hook.
+func newHook(source, hook io.Reader) io.Reader {
+        if hook == nil {
+                return &hookReader{source: source}
+        }
+        return &hookReader{
+                source: source,
+                hook:   hook,
+        }
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/assume_role.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/assume_role.go
new file mode 100644
index 0000000..800c4a2
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/assume_role.go
@@ -0,0 +1,242 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2020 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 credentials
+
+import (
+        "bytes"
+        "crypto/sha256"
+        "encoding/hex"
+        "encoding/xml"
+        "errors"
+        "io"
+        "net/http"
+        "net/url"
+        "strconv"
+        "strings"
+        "time"
+
+        "github.com/minio/minio-go/v7/pkg/signer"
+)
+
+// AssumeRoleResponse contains the result of successful AssumeRole request.
+type AssumeRoleResponse struct {
+        XMLName xml.Name `xml:"https://sts.amazonaws.com/doc/2011-06-15/ AssumeRoleResponse" json:"-"`
+
+        Result           AssumeRoleResult `xml:"AssumeRoleResult"`
+        ResponseMetadata struct {
+                RequestID string `xml:"RequestId,omitempty"`
+        } `xml:"ResponseMetadata,omitempty"`
+}
+
+// AssumeRoleResult - Contains the response to a successful AssumeRole
+// request, including temporary credentials that can be used to make
+// MinIO API requests.
+type AssumeRoleResult struct {
+        // The identifiers for the temporary security credentials that the operation
+        // returns.
+        AssumedRoleUser AssumedRoleUser `xml:",omitempty"`
+
+        // The temporary security credentials, which include an access key ID, a secret
+        // access key, and a security (or session) token.
+        //
+        // Note: The size of the security token that STS APIs return is not fixed. We
+        // strongly recommend that you make no assumptions about the maximum size. As
+        // of this writing, the typical size is less than 4096 bytes, but that can vary.
+        // Also, future updates to AWS might require larger sizes.
+        Credentials struct {
+                AccessKey    string    `xml:"AccessKeyId" json:"accessKey,omitempty"`
+                SecretKey    string    `xml:"SecretAccessKey" json:"secretKey,omitempty"`
+                Expiration   time.Time `xml:"Expiration" json:"expiration,omitempty"`
+                SessionToken string    `xml:"SessionToken" json:"sessionToken,omitempty"`
+        } `xml:",omitempty"`
+
+        // A percentage value that indicates the size of the policy in packed form.
+        // The service rejects any policy with a packed size greater than 100 percent,
+        // which means the policy exceeded the allowed space.
+        PackedPolicySize int `xml:",omitempty"`
+}
+
+// A STSAssumeRole retrieves credentials from MinIO service, and keeps track if
+// those credentials are expired.
+type STSAssumeRole struct {
+        Expiry
+
+        // Required http Client to use when connecting to MinIO STS service.
+        Client *http.Client
+
+        // STS endpoint to fetch STS credentials.
+        STSEndpoint string
+
+        // various options for this request.
+        Options STSAssumeRoleOptions
+}
+
+// STSAssumeRoleOptions collection of various input options
+// to obtain AssumeRole credentials.
+type STSAssumeRoleOptions struct {
+        // Mandatory inputs.
+        AccessKey string
+        SecretKey string
+
+        SessionToken string // Optional if the first request is made with temporary credentials.
+        Policy       string // Optional to assign a policy to the assumed role
+
+        Location        string // Optional commonly needed with AWS STS.
+        DurationSeconds int    // Optional defaults to 1 hour.
+
+        // Optional only valid if using with AWS STS
+        RoleARN         string
+        RoleSessionName string
+        ExternalID      string
+}
+
+// NewSTSAssumeRole returns a pointer to a new
+// Credentials object wrapping the STSAssumeRole.
+func NewSTSAssumeRole(stsEndpoint string, opts STSAssumeRoleOptions) (*Credentials, error) {
+        if stsEndpoint == "" {
+                return nil, errors.New("STS endpoint cannot be empty")
+        }
+        if opts.AccessKey == "" || opts.SecretKey == "" {
+                return nil, errors.New("AssumeRole credentials access/secretkey is mandatory")
+        }
+        return New(&STSAssumeRole{
+                Client: &http.Client{
+                        Transport: http.DefaultTransport,
+                },
+                STSEndpoint: stsEndpoint,
+                Options:     opts,
+        }), nil
+}
+
+const defaultDurationSeconds = 3600
+
+// closeResponse close non nil response with any response Body.
+// convenient wrapper to drain any remaining data on response body.
+//
+// Subsequently this allows golang http RoundTripper
+// to re-use the same connection for future requests.
+func closeResponse(resp *http.Response) {
+        // Callers should close resp.Body when done reading from it.
+        // If resp.Body is not closed, the Client's underlying RoundTripper
+        // (typically Transport) may not be able to re-use a persistent TCP
+        // connection to the server for a subsequent "keep-alive" request.
+        if resp != nil && resp.Body != nil {
+                // Drain any remaining Body and then close the connection.
+                // Without this closing connection would disallow re-using
+                // the same connection for future uses.
+                //  - http://stackoverflow.com/a/17961593/4465767
+                io.Copy(io.Discard, resp.Body)
+                resp.Body.Close()
+        }
+}
+
+func getAssumeRoleCredentials(clnt *http.Client, endpoint string, opts STSAssumeRoleOptions) (AssumeRoleResponse, error) {
+        v := url.Values{}
+        v.Set("Action", "AssumeRole")
+        v.Set("Version", STSVersion)
+        if opts.RoleARN != "" {
+                v.Set("RoleArn", opts.RoleARN)
+        }
+        if opts.RoleSessionName != "" {
+                v.Set("RoleSessionName", opts.RoleSessionName)
+        }
+        if opts.DurationSeconds > defaultDurationSeconds {
+                v.Set("DurationSeconds", strconv.Itoa(opts.DurationSeconds))
+        } else {
+                v.Set("DurationSeconds", strconv.Itoa(defaultDurationSeconds))
+        }
+        if opts.Policy != "" {
+                v.Set("Policy", opts.Policy)
+        }
+        if opts.ExternalID != "" {
+                v.Set("ExternalId", opts.ExternalID)
+        }
+
+        u, err := url.Parse(endpoint)
+        if err != nil {
+                return AssumeRoleResponse{}, err
+        }
+        u.Path = "/"
+
+        postBody := strings.NewReader(v.Encode())
+        hash := sha256.New()
+        if _, err = io.Copy(hash, postBody); err != nil {
+                return AssumeRoleResponse{}, err
+        }
+        postBody.Seek(0, 0)
+
+        req, err := http.NewRequest(http.MethodPost, u.String(), postBody)
+        if err != nil {
+                return AssumeRoleResponse{}, err
+        }
+        req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+        req.Header.Set("X-Amz-Content-Sha256", hex.EncodeToString(hash.Sum(nil)))
+        if opts.SessionToken != "" {
+                req.Header.Set("X-Amz-Security-Token", opts.SessionToken)
+        }
+        req = signer.SignV4STS(*req, opts.AccessKey, opts.SecretKey, opts.Location)
+
+        resp, err := clnt.Do(req)
+        if err != nil {
+                return AssumeRoleResponse{}, err
+        }
+        defer closeResponse(resp)
+        if resp.StatusCode != http.StatusOK {
+                var errResp ErrorResponse
+                buf, err := io.ReadAll(resp.Body)
+                if err != nil {
+                        return AssumeRoleResponse{}, err
+                }
+                _, err = xmlDecodeAndBody(bytes.NewReader(buf), &errResp)
+                if err != nil {
+                        var s3Err Error
+                        if _, err = xmlDecodeAndBody(bytes.NewReader(buf), &s3Err); err != nil {
+                                return AssumeRoleResponse{}, err
+                        }
+                        errResp.RequestID = s3Err.RequestID
+                        errResp.STSError.Code = s3Err.Code
+                        errResp.STSError.Message = s3Err.Message
+                }
+                return AssumeRoleResponse{}, errResp
+        }
+
+        a := AssumeRoleResponse{}
+        if _, err = xmlDecodeAndBody(resp.Body, &a); err != nil {
+                return AssumeRoleResponse{}, err
+        }
+        return a, nil
+}
+
+// Retrieve retrieves credentials from the MinIO service.
+// Error will be returned if the request fails.
+func (m *STSAssumeRole) Retrieve() (Value, error) {
+        a, err := getAssumeRoleCredentials(m.Client, m.STSEndpoint, m.Options)
+        if err != nil {
+                return Value{}, err
+        }
+
+        // Expiry window is set to 10secs.
+        m.SetExpiration(a.Result.Credentials.Expiration, DefaultExpiryWindow)
+
+        return Value{
+                AccessKeyID:     a.Result.Credentials.AccessKey,
+                SecretAccessKey: a.Result.Credentials.SecretKey,
+                SessionToken:    a.Result.Credentials.SessionToken,
+                SignerType:      SignatureV4,
+        }, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/chain.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/chain.go
new file mode 100644
index 0000000..ddccfb1
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/chain.go
@@ -0,0 +1,88 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 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 credentials
+
+// A Chain will search for a provider which returns credentials
+// and cache that provider until Retrieve is called again.
+//
+// The Chain provides a way of chaining multiple providers together
+// which will pick the first available using priority order of the
+// Providers in the list.
+//
+// If none of the Providers retrieve valid credentials Value, ChainProvider's
+// Retrieve() will return the no credentials value.
+//
+// If a Provider is found which returns valid credentials Value ChainProvider
+// will cache that Provider for all calls to IsExpired(), until Retrieve is
+// called again after IsExpired() is true.
+//
+//      creds := credentials.NewChainCredentials(
+//          []credentials.Provider{
+//              &credentials.EnvAWSS3{},
+//              &credentials.EnvMinio{},
+//          })
+//
+//      // Usage of ChainCredentials.
+//      mc, err := minio.NewWithCredentials(endpoint, creds, secure, "us-east-1")
+//      if err != nil {
+//           log.Fatalln(err)
+//      }
+type Chain struct {
+        Providers []Provider
+        curr      Provider
+}
+
+// NewChainCredentials returns a pointer to a new Credentials object
+// wrapping a chain of providers.
+func NewChainCredentials(providers []Provider) *Credentials {
+        return New(&Chain{
+                Providers: append([]Provider{}, providers...),
+        })
+}
+
+// Retrieve returns the credentials value, returns no credentials(anonymous)
+// if no credentials provider returned any value.
+//
+// If a provider is found with credentials, it will be cached and any calls
+// to IsExpired() will return the expired state of the cached provider.
+func (c *Chain) Retrieve() (Value, error) {
+        for _, p := range c.Providers {
+                creds, _ := p.Retrieve()
+                // Always prioritize non-anonymous providers, if any.
+                if creds.AccessKeyID == "" && creds.SecretAccessKey == "" {
+                        continue
+                }
+                c.curr = p
+                return creds, nil
+        }
+        // At this point we have exhausted all the providers and
+        // are left without any credentials return anonymous.
+        return Value{
+                SignerType: SignatureAnonymous,
+        }, nil
+}
+
+// IsExpired will returned the expired state of the currently cached provider
+// if there is one. If there is no current provider, true will be returned.
+func (c *Chain) IsExpired() bool {
+        if c.curr != nil {
+                return c.curr.IsExpired()
+        }
+
+        return true
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/config.json.sample b/vendor/github.com/minio/minio-go/v7/pkg/credentials/config.json.sample
new file mode 100644
index 0000000..d793c9e
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/config.json.sample
@@ -0,0 +1,17 @@
+{
+        "version": "8",
+        "hosts": {
+                "play": {
+                        "url": "https://play.min.io",
+                        "accessKey": "Q3AM3UQ867SPQQA43P2F",
+                        "secretKey": "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG",
+                        "api": "S3v2"
+                },
+                "s3": {
+                        "url": "https://s3.amazonaws.com",
+                        "accessKey": "accessKey",
+                        "secretKey": "secret",
+                        "api": "S3v4"
+                }
+        }
+}
\ No newline at end of file
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/credentials.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/credentials.go
new file mode 100644
index 0000000..af61049
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/credentials.go
@@ -0,0 +1,193 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 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 credentials
+
+import (
+        "sync"
+        "time"
+)
+
+const (
+        // STSVersion sts version string
+        STSVersion = "2011-06-15"
+
+        // How much duration to slash from the given expiration duration
+        defaultExpiryWindow = 0.8
+)
+
+// A Value is the AWS credentials value for individual credential fields.
+type Value struct {
+        // AWS Access key ID
+        AccessKeyID string
+
+        // AWS Secret Access Key
+        SecretAccessKey string
+
+        // AWS Session Token
+        SessionToken string
+
+        // Signature Type.
+        SignerType SignatureType
+}
+
+// A Provider is the interface for any component which will provide credentials
+// Value. A provider is required to manage its own Expired state, and what to
+// be expired means.
+type Provider interface {
+        // Retrieve returns nil if it successfully retrieved the value.
+        // Error is returned if the value were not obtainable, or empty.
+        Retrieve() (Value, error)
+
+        // IsExpired returns if the credentials are no longer valid, and need
+        // to be retrieved.
+        IsExpired() bool
+}
+
+// A Expiry provides shared expiration logic to be used by credentials
+// providers to implement expiry functionality.
+//
+// The best method to use this struct is as an anonymous field within the
+// provider's struct.
+//
+// Example:
+//
+//      type IAMCredentialProvider struct {
+//          Expiry
+//          ...
+//      }
+type Expiry struct {
+        // The date/time when to expire on
+        expiration time.Time
+
+        // If set will be used by IsExpired to determine the current time.
+        // Defaults to time.Now if CurrentTime is not set.
+        CurrentTime func() time.Time
+}
+
+// SetExpiration sets the expiration IsExpired will check when called.
+//
+// If window is greater than 0 the expiration time will be reduced by the
+// window value.
+//
+// Using a window is helpful to trigger credentials to expire sooner than
+// the expiration time given to ensure no requests are made with expired
+// tokens.
+func (e *Expiry) SetExpiration(expiration time.Time, window time.Duration) {
+        if e.CurrentTime == nil {
+                e.CurrentTime = time.Now
+        }
+        cut := window
+        if cut < 0 {
+                expireIn := expiration.Sub(e.CurrentTime())
+                cut = time.Duration(float64(expireIn) * (1 - defaultExpiryWindow))
+        }
+        e.expiration = expiration.Add(-cut)
+}
+
+// IsExpired returns if the credentials are expired.
+func (e *Expiry) IsExpired() bool {
+        if e.CurrentTime == nil {
+                e.CurrentTime = time.Now
+        }
+        return e.expiration.Before(e.CurrentTime())
+}
+
+// Credentials - A container for synchronous safe retrieval of credentials Value.
+// Credentials will cache the credentials value until they expire. Once the value
+// expires the next Get will attempt to retrieve valid credentials.
+//
+// Credentials is safe to use across multiple goroutines and will manage the
+// synchronous state so the Providers do not need to implement their own
+// synchronization.
+//
+// The first Credentials.Get() will always call Provider.Retrieve() to get the
+// first instance of the credentials Value. All calls to Get() after that
+// will return the cached credentials Value until IsExpired() returns true.
+type Credentials struct {
+        sync.Mutex
+
+        creds        Value
+        forceRefresh bool
+        provider     Provider
+}
+
+// New returns a pointer to a new Credentials with the provider set.
+func New(provider Provider) *Credentials {
+        return &Credentials{
+                provider:     provider,
+                forceRefresh: true,
+        }
+}
+
+// Get returns the credentials value, or error if the credentials Value failed
+// to be retrieved.
+//
+// Will return the cached credentials Value if it has not expired. If the
+// credentials Value has expired the Provider's Retrieve() will be called
+// to refresh the credentials.
+//
+// If Credentials.Expire() was called the credentials Value will be force
+// expired, and the next call to Get() will cause them to be refreshed.
+func (c *Credentials) Get() (Value, error) {
+        if c == nil {
+                return Value{}, nil
+        }
+
+        c.Lock()
+        defer c.Unlock()
+
+        if c.isExpired() {
+                creds, err := c.provider.Retrieve()
+                if err != nil {
+                        return Value{}, err
+                }
+                c.creds = creds
+                c.forceRefresh = false
+        }
+
+        return c.creds, nil
+}
+
+// Expire expires the credentials and forces them to be retrieved on the
+// next call to Get().
+//
+// This will override the Provider's expired state, and force Credentials
+// to call the Provider's Retrieve().
+func (c *Credentials) Expire() {
+        c.Lock()
+        defer c.Unlock()
+
+        c.forceRefresh = true
+}
+
+// IsExpired returns if the credentials are no longer valid, and need
+// to be refreshed.
+//
+// If the Credentials were forced to be expired with Expire() this will
+// reflect that override.
+func (c *Credentials) IsExpired() bool {
+        c.Lock()
+        defer c.Unlock()
+
+        return c.isExpired()
+}
+
+// isExpired helper method wrapping the definition of expired credentials.
+func (c *Credentials) isExpired() bool {
+        return c.forceRefresh || c.provider.IsExpired()
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/credentials.json b/vendor/github.com/minio/minio-go/v7/pkg/credentials/credentials.json
new file mode 100644
index 0000000..afbfad5
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/credentials.json
@@ -0,0 +1,7 @@
+{
+    "Version": 1,
+    "SessionToken": "token",
+    "AccessKeyId": "accessKey",
+    "SecretAccessKey": "secret",
+    "Expiration": "9999-04-27T16:02:25.000Z"
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/credentials.sample b/vendor/github.com/minio/minio-go/v7/pkg/credentials/credentials.sample
new file mode 100644
index 0000000..e2dc1bf
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/credentials.sample
@@ -0,0 +1,15 @@
+[default]
+aws_access_key_id = accessKey
+aws_secret_access_key = secret
+aws_session_token = token
+
+[no_token]
+aws_access_key_id = accessKey
+aws_secret_access_key = secret
+
+[with_colon]
+aws_access_key_id: accessKey
+aws_secret_access_key: secret
+
+[with_process]
+credential_process = /bin/cat credentials.json
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/doc.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/doc.go
new file mode 100644
index 0000000..fbfb105
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/doc.go
@@ -0,0 +1,60 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 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 credentials provides credential retrieval and management
+// for S3 compatible object storage.
+//
+// By default the Credentials.Get() will cache the successful result of a
+// Provider's Retrieve() until Provider.IsExpired() returns true. At which
+// point Credentials will call Provider's Retrieve() to get new credential Value.
+//
+// The Provider is responsible for determining when credentials have expired.
+// It is also important to note that Credentials will always call Retrieve the
+// first time Credentials.Get() is called.
+//
+// Example of using the environment variable credentials.
+//
+//      creds := NewFromEnv()
+//      // Retrieve the credentials value
+//      credValue, err := creds.Get()
+//      if err != nil {
+//          // handle error
+//      }
+//
+// Example of forcing credentials to expire and be refreshed on the next Get().
+// This may be helpful to proactively expire credentials and refresh them sooner
+// than they would naturally expire on their own.
+//
+//      creds := NewFromIAM("")
+//      creds.Expire()
+//      credsValue, err := creds.Get()
+//      // New credentials will be retrieved instead of from cache.
+//
+// # Custom Provider
+//
+// Each Provider built into this package also provides a helper method to generate
+// a Credentials pointer setup with the provider. To use a custom Provider just
+// create a type which satisfies the Provider interface and pass it to the
+// NewCredentials method.
+//
+//      type MyProvider struct{}
+//      func (m *MyProvider) Retrieve() (Value, error) {...}
+//      func (m *MyProvider) IsExpired() bool {...}
+//
+//      creds := NewCredentials(&MyProvider{})
+//      credValue, err := creds.Get()
+package credentials
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/env_aws.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/env_aws.go
new file mode 100644
index 0000000..b6e60d0
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/env_aws.go
@@ -0,0 +1,71 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 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 credentials
+
+import "os"
+
+// A EnvAWS retrieves credentials from the environment variables of the
+// running process. EnvAWSironment credentials never expire.
+//
+// EnvAWSironment variables used:
+//
+// * Access Key ID:     AWS_ACCESS_KEY_ID or AWS_ACCESS_KEY.
+// * Secret Access Key: AWS_SECRET_ACCESS_KEY or AWS_SECRET_KEY.
+// * Secret Token:      AWS_SESSION_TOKEN.
+type EnvAWS struct {
+        retrieved bool
+}
+
+// NewEnvAWS returns a pointer to a new Credentials object
+// wrapping the environment variable provider.
+func NewEnvAWS() *Credentials {
+        return New(&EnvAWS{})
+}
+
+// Retrieve retrieves the keys from the environment.
+func (e *EnvAWS) Retrieve() (Value, error) {
+        e.retrieved = false
+
+        id := os.Getenv("AWS_ACCESS_KEY_ID")
+        if id == "" {
+                id = os.Getenv("AWS_ACCESS_KEY")
+        }
+
+        secret := os.Getenv("AWS_SECRET_ACCESS_KEY")
+        if secret == "" {
+                secret = os.Getenv("AWS_SECRET_KEY")
+        }
+
+        signerType := SignatureV4
+        if id == "" || secret == "" {
+                signerType = SignatureAnonymous
+        }
+
+        e.retrieved = true
+        return Value{
+                AccessKeyID:     id,
+                SecretAccessKey: secret,
+                SessionToken:    os.Getenv("AWS_SESSION_TOKEN"),
+                SignerType:      signerType,
+        }, nil
+}
+
+// IsExpired returns if the credentials have been retrieved.
+func (e *EnvAWS) IsExpired() bool {
+        return !e.retrieved
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/env_minio.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/env_minio.go
new file mode 100644
index 0000000..5bfeab1
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/env_minio.go
@@ -0,0 +1,68 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 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 credentials
+
+import "os"
+
+// A EnvMinio retrieves credentials from the environment variables of the
+// running process. EnvMinioironment credentials never expire.
+//
+// Environment variables used:
+//
+// * Access Key ID:     MINIO_ACCESS_KEY.
+// * Secret Access Key: MINIO_SECRET_KEY.
+// * Access Key ID:     MINIO_ROOT_USER.
+// * Secret Access Key: MINIO_ROOT_PASSWORD.
+type EnvMinio struct {
+        retrieved bool
+}
+
+// NewEnvMinio returns a pointer to a new Credentials object
+// wrapping the environment variable provider.
+func NewEnvMinio() *Credentials {
+        return New(&EnvMinio{})
+}
+
+// Retrieve retrieves the keys from the environment.
+func (e *EnvMinio) Retrieve() (Value, error) {
+        e.retrieved = false
+
+        id := os.Getenv("MINIO_ROOT_USER")
+        secret := os.Getenv("MINIO_ROOT_PASSWORD")
+
+        signerType := SignatureV4
+        if id == "" || secret == "" {
+                id = os.Getenv("MINIO_ACCESS_KEY")
+                secret = os.Getenv("MINIO_SECRET_KEY")
+                if id == "" || secret == "" {
+                        signerType = SignatureAnonymous
+                }
+        }
+
+        e.retrieved = true
+        return Value{
+                AccessKeyID:     id,
+                SecretAccessKey: secret,
+                SignerType:      signerType,
+        }, nil
+}
+
+// IsExpired returns if the credentials have been retrieved.
+func (e *EnvMinio) IsExpired() bool {
+        return !e.retrieved
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/error_response.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/error_response.go
new file mode 100644
index 0000000..07a9c2f
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/error_response.go
@@ -0,0 +1,95 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2021 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 credentials
+
+import (
+        "bytes"
+        "encoding/xml"
+        "fmt"
+        "io"
+)
+
+// ErrorResponse - Is the typed error returned.
+// ErrorResponse struct should be comparable since it is compared inside
+// golang http API (https://github.com/golang/go/issues/29768)
+type ErrorResponse struct {
+        XMLName  xml.Name `xml:"https://sts.amazonaws.com/doc/2011-06-15/ ErrorResponse" json:"-"`
+        STSError struct {
+                Type    string `xml:"Type"`
+                Code    string `xml:"Code"`
+                Message string `xml:"Message"`
+        } `xml:"Error"`
+        RequestID string `xml:"RequestId"`
+}
+
+// Error - Is the typed error returned by all API operations.
+type Error struct {
+        XMLName    xml.Name `xml:"Error" json:"-"`
+        Code       string
+        Message    string
+        BucketName string
+        Key        string
+        Resource   string
+        RequestID  string `xml:"RequestId"`
+        HostID     string `xml:"HostId"`
+
+        // Region where the bucket is located. This header is returned
+        // only in HEAD bucket and ListObjects response.
+        Region string
+
+        // Captures the server string returned in response header.
+        Server string
+
+        // Underlying HTTP status code for the returned error
+        StatusCode int `xml:"-" json:"-"`
+}
+
+// Error - Returns S3 error string.
+func (e Error) Error() string {
+        if e.Message == "" {
+                return fmt.Sprintf("Error response code %s.", e.Code)
+        }
+        return e.Message
+}
+
+// Error - Returns STS error string.
+func (e ErrorResponse) Error() string {
+        if e.STSError.Message == "" {
+                return fmt.Sprintf("Error response code %s.", e.STSError.Code)
+        }
+        return e.STSError.Message
+}
+
+// xmlDecoder provide decoded value in xml.
+func xmlDecoder(body io.Reader, v interface{}) error {
+        d := xml.NewDecoder(body)
+        return d.Decode(v)
+}
+
+// xmlDecodeAndBody reads the whole body up to 1MB and
+// tries to XML decode it into v.
+// The body that was read and any error from reading or decoding is returned.
+func xmlDecodeAndBody(bodyReader io.Reader, v interface{}) ([]byte, error) {
+        // read the whole body (up to 1MB)
+        const maxBodyLength = 1 << 20
+        body, err := io.ReadAll(io.LimitReader(bodyReader, maxBodyLength))
+        if err != nil {
+                return nil, err
+        }
+        return bytes.TrimSpace(body), xmlDecoder(bytes.NewReader(body), v)
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/file_aws_credentials.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/file_aws_credentials.go
new file mode 100644
index 0000000..5b07376
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/file_aws_credentials.go
@@ -0,0 +1,157 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 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 credentials
+
+import (
+        "encoding/json"
+        "errors"
+        "os"
+        "os/exec"
+        "path/filepath"
+        "strings"
+        "time"
+
+        ini "gopkg.in/ini.v1"
+)
+
+// A externalProcessCredentials stores the output of a credential_process
+type externalProcessCredentials struct {
+        Version         int
+        SessionToken    string
+        AccessKeyID     string `json:"AccessKeyId"`
+        SecretAccessKey string
+        Expiration      time.Time
+}
+
+// A FileAWSCredentials retrieves credentials from the current user's home
+// directory, and keeps track if those credentials are expired.
+//
+// Profile ini file example: $HOME/.aws/credentials
+type FileAWSCredentials struct {
+        Expiry
+
+        // Path to the shared credentials file.
+        //
+        // If empty will look for "AWS_SHARED_CREDENTIALS_FILE" env variable. If the
+        // env value is empty will default to current user's home directory.
+        // Linux/OSX: "$HOME/.aws/credentials"
+        // Windows:   "%USERPROFILE%\.aws\credentials"
+        Filename string
+
+        // AWS Profile to extract credentials from the shared credentials file. If empty
+        // will default to environment variable "AWS_PROFILE" or "default" if
+        // environment variable is also not set.
+        Profile string
+
+        // retrieved states if the credentials have been successfully retrieved.
+        retrieved bool
+}
+
+// NewFileAWSCredentials returns a pointer to a new Credentials object
+// wrapping the Profile file provider.
+func NewFileAWSCredentials(filename, profile string) *Credentials {
+        return New(&FileAWSCredentials{
+                Filename: filename,
+                Profile:  profile,
+        })
+}
+
+// Retrieve reads and extracts the shared credentials from the current
+// users home directory.
+func (p *FileAWSCredentials) Retrieve() (Value, error) {
+        if p.Filename == "" {
+                p.Filename = os.Getenv("AWS_SHARED_CREDENTIALS_FILE")
+                if p.Filename == "" {
+                        homeDir, err := os.UserHomeDir()
+                        if err != nil {
+                                return Value{}, err
+                        }
+                        p.Filename = filepath.Join(homeDir, ".aws", "credentials")
+                }
+        }
+        if p.Profile == "" {
+                p.Profile = os.Getenv("AWS_PROFILE")
+                if p.Profile == "" {
+                        p.Profile = "default"
+                }
+        }
+
+        p.retrieved = false
+
+        iniProfile, err := loadProfile(p.Filename, p.Profile)
+        if err != nil {
+                return Value{}, err
+        }
+
+        // Default to empty string if not found.
+        id := iniProfile.Key("aws_access_key_id")
+        // Default to empty string if not found.
+        secret := iniProfile.Key("aws_secret_access_key")
+        // Default to empty string if not found.
+        token := iniProfile.Key("aws_session_token")
+
+        // If credential_process is defined, obtain credentials by executing
+        // the external process
+        credentialProcess := strings.TrimSpace(iniProfile.Key("credential_process").String())
+        if credentialProcess != "" {
+                args := strings.Fields(credentialProcess)
+                if len(args) <= 1 {
+                        return Value{}, errors.New("invalid credential process args")
+                }
+                cmd := exec.Command(args[0], args[1:]...)
+                out, err := cmd.Output()
+                if err != nil {
+                        return Value{}, err
+                }
+                var externalProcessCredentials externalProcessCredentials
+                err = json.Unmarshal([]byte(out), &externalProcessCredentials)
+                if err != nil {
+                        return Value{}, err
+                }
+                p.retrieved = true
+                p.SetExpiration(externalProcessCredentials.Expiration, DefaultExpiryWindow)
+                return Value{
+                        AccessKeyID:     externalProcessCredentials.AccessKeyID,
+                        SecretAccessKey: externalProcessCredentials.SecretAccessKey,
+                        SessionToken:    externalProcessCredentials.SessionToken,
+                        SignerType:      SignatureV4,
+                }, nil
+        }
+        p.retrieved = true
+        return Value{
+                AccessKeyID:     id.String(),
+                SecretAccessKey: secret.String(),
+                SessionToken:    token.String(),
+                SignerType:      SignatureV4,
+        }, nil
+}
+
+// loadProfiles loads from the file pointed to by shared credentials filename for profile.
+// The credentials retrieved from the profile will be returned or error. Error will be
+// returned if it fails to read from the file, or the data is invalid.
+func loadProfile(filename, profile string) (*ini.Section, error) {
+        config, err := ini.Load(filename)
+        if err != nil {
+                return nil, err
+        }
+        iniProfile, err := config.GetSection(profile)
+        if err != nil {
+                return nil, err
+        }
+        return iniProfile, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/file_minio_client.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/file_minio_client.go
new file mode 100644
index 0000000..eb77767
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/file_minio_client.go
@@ -0,0 +1,139 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 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 credentials
+
+import (
+        "os"
+        "path/filepath"
+        "runtime"
+
+        jsoniter "github.com/json-iterator/go"
+)
+
+// A FileMinioClient retrieves credentials from the current user's home
+// directory, and keeps track if those credentials are expired.
+//
+// Configuration file example: $HOME/.mc/config.json
+type FileMinioClient struct {
+        // Path to the shared credentials file.
+        //
+        // If empty will look for "MINIO_SHARED_CREDENTIALS_FILE" env variable. If the
+        // env value is empty will default to current user's home directory.
+        // Linux/OSX: "$HOME/.mc/config.json"
+        // Windows:   "%USERALIAS%\mc\config.json"
+        Filename string
+
+        // MinIO Alias to extract credentials from the shared credentials file. If empty
+        // will default to environment variable "MINIO_ALIAS" or "default" if
+        // environment variable is also not set.
+        Alias string
+
+        // retrieved states if the credentials have been successfully retrieved.
+        retrieved bool
+}
+
+// NewFileMinioClient returns a pointer to a new Credentials object
+// wrapping the Alias file provider.
+func NewFileMinioClient(filename, alias string) *Credentials {
+        return New(&FileMinioClient{
+                Filename: filename,
+                Alias:    alias,
+        })
+}
+
+// Retrieve reads and extracts the shared credentials from the current
+// users home directory.
+func (p *FileMinioClient) Retrieve() (Value, error) {
+        if p.Filename == "" {
+                if value, ok := os.LookupEnv("MINIO_SHARED_CREDENTIALS_FILE"); ok {
+                        p.Filename = value
+                } else {
+                        homeDir, err := os.UserHomeDir()
+                        if err != nil {
+                                return Value{}, err
+                        }
+                        p.Filename = filepath.Join(homeDir, ".mc", "config.json")
+                        if runtime.GOOS == "windows" {
+                                p.Filename = filepath.Join(homeDir, "mc", "config.json")
+                        }
+                }
+        }
+
+        if p.Alias == "" {
+                p.Alias = os.Getenv("MINIO_ALIAS")
+                if p.Alias == "" {
+                        p.Alias = "s3"
+                }
+        }
+
+        p.retrieved = false
+
+        hostCfg, err := loadAlias(p.Filename, p.Alias)
+        if err != nil {
+                return Value{}, err
+        }
+
+        p.retrieved = true
+        return Value{
+                AccessKeyID:     hostCfg.AccessKey,
+                SecretAccessKey: hostCfg.SecretKey,
+                SignerType:      parseSignatureType(hostCfg.API),
+        }, nil
+}
+
+// IsExpired returns if the shared credentials have expired.
+func (p *FileMinioClient) IsExpired() bool {
+        return !p.retrieved
+}
+
+// hostConfig configuration of a host.
+type hostConfig struct {
+        URL       string `json:"url"`
+        AccessKey string `json:"accessKey"`
+        SecretKey string `json:"secretKey"`
+        API       string `json:"api"`
+}
+
+// config config version.
+type config struct {
+        Version string                `json:"version"`
+        Hosts   map[string]hostConfig `json:"hosts"`
+        Aliases map[string]hostConfig `json:"aliases"`
+}
+
+// loadAliass loads from the file pointed to by shared credentials filename for alias.
+// The credentials retrieved from the alias will be returned or error. Error will be
+// returned if it fails to read from the file.
+func loadAlias(filename, alias string) (hostConfig, error) {
+        cfg := &config{}
+        json := jsoniter.ConfigCompatibleWithStandardLibrary
+
+        configBytes, err := os.ReadFile(filename)
+        if err != nil {
+                return hostConfig{}, err
+        }
+        if err = json.Unmarshal(configBytes, cfg); err != nil {
+                return hostConfig{}, err
+        }
+
+        if cfg.Version == "10" {
+                return cfg.Aliases[alias], nil
+        }
+
+        return cfg.Hosts[alias], nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/iam_aws.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/iam_aws.go
new file mode 100644
index 0000000..c5153c4
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/iam_aws.go
@@ -0,0 +1,433 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 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 credentials
+
+import (
+        "bufio"
+        "context"
+        "errors"
+        "fmt"
+        "io"
+        "net"
+        "net/http"
+        "net/url"
+        "os"
+        "path"
+        "strings"
+        "time"
+
+        jsoniter "github.com/json-iterator/go"
+)
+
+// DefaultExpiryWindow - Default expiry window.
+// ExpiryWindow will allow the credentials to trigger refreshing
+// prior to the credentials actually expiring. This is beneficial
+// so race conditions with expiring credentials do not cause
+// request to fail unexpectedly due to ExpiredTokenException exceptions.
+// DefaultExpiryWindow can be used as parameter to (*Expiry).SetExpiration.
+// When used the tokens refresh will be triggered when 80% of the elapsed
+// time until the actual expiration time is passed.
+const DefaultExpiryWindow = -1
+
+// A IAM retrieves credentials from the EC2 service, and keeps track if
+// those credentials are expired.
+type IAM struct {
+        Expiry
+
+        // Required http Client to use when connecting to IAM metadata service.
+        Client *http.Client
+
+        // Custom endpoint to fetch IAM role credentials.
+        Endpoint string
+
+        // Region configurable custom region for STS
+        Region string
+
+        // Support for container authorization token https://docs.aws.amazon.com/sdkref/latest/guide/feature-container-credentials.html
+        Container struct {
+                AuthorizationToken     string
+                CredentialsFullURI     string
+                CredentialsRelativeURI string
+        }
+
+        // EKS based k8s RBAC authorization - https://docs.aws.amazon.com/eks/latest/userguide/pod-configuration.html
+        EKSIdentity struct {
+                TokenFile       string
+                RoleARN         string
+                RoleSessionName string
+        }
+}
+
+// IAM Roles for Amazon EC2
+// http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html
+const (
+        DefaultIAMRoleEndpoint      = "http://169.254.169.254"
+        DefaultECSRoleEndpoint      = "http://169.254.170.2"
+        DefaultSTSRoleEndpoint      = "https://sts.amazonaws.com"
+        DefaultIAMSecurityCredsPath = "/latest/meta-data/iam/security-credentials/"
+        TokenRequestTTLHeader       = "X-aws-ec2-metadata-token-ttl-seconds"
+        TokenPath                   = "/latest/api/token"
+        TokenTTL                    = "21600"
+        TokenRequestHeader          = "X-aws-ec2-metadata-token"
+)
+
+// NewIAM returns a pointer to a new Credentials object wrapping the IAM.
+func NewIAM(endpoint string) *Credentials {
+        return New(&IAM{
+                Client: &http.Client{
+                        Transport: http.DefaultTransport,
+                },
+                Endpoint: endpoint,
+        })
+}
+
+// Retrieve retrieves credentials from the EC2 service.
+// Error will be returned if the request fails, or unable to extract
+// the desired
+func (m *IAM) Retrieve() (Value, error) {
+        token := os.Getenv("AWS_CONTAINER_AUTHORIZATION_TOKEN")
+        if token == "" {
+                token = m.Container.AuthorizationToken
+        }
+
+        relativeURI := os.Getenv("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI")
+        if relativeURI == "" {
+                relativeURI = m.Container.CredentialsRelativeURI
+        }
+
+        fullURI := os.Getenv("AWS_CONTAINER_CREDENTIALS_FULL_URI")
+        if fullURI == "" {
+                fullURI = m.Container.CredentialsFullURI
+        }
+
+        identityFile := os.Getenv("AWS_WEB_IDENTITY_TOKEN_FILE")
+        if identityFile == "" {
+                identityFile = m.EKSIdentity.TokenFile
+        }
+
+        roleArn := os.Getenv("AWS_ROLE_ARN")
+        if roleArn == "" {
+                roleArn = m.EKSIdentity.RoleARN
+        }
+
+        roleSessionName := os.Getenv("AWS_ROLE_SESSION_NAME")
+        if roleSessionName == "" {
+                roleSessionName = m.EKSIdentity.RoleSessionName
+        }
+
+        region := os.Getenv("AWS_REGION")
+        if region == "" {
+                region = m.Region
+        }
+
+        var roleCreds ec2RoleCredRespBody
+        var err error
+
+        endpoint := m.Endpoint
+        switch {
+        case identityFile != "":
+                if len(endpoint) == 0 {
+                        if region != "" {
+                                if strings.HasPrefix(region, "cn-") {
+                                        endpoint = "https://sts." + region + ".amazonaws.com.cn"
+                                } else {
+                                        endpoint = "https://sts." + region + ".amazonaws.com"
+                                }
+                        } else {
+                                endpoint = DefaultSTSRoleEndpoint
+                        }
+                }
+
+                creds := &STSWebIdentity{
+                        Client:      m.Client,
+                        STSEndpoint: endpoint,
+                        GetWebIDTokenExpiry: func() (*WebIdentityToken, error) {
+                                token, err := os.ReadFile(identityFile)
+                                if err != nil {
+                                        return nil, err
+                                }
+
+                                return &WebIdentityToken{Token: string(token)}, nil
+                        },
+                        RoleARN:         roleArn,
+                        roleSessionName: roleSessionName,
+                }
+
+                stsWebIdentityCreds, err := creds.Retrieve()
+                if err == nil {
+                        m.SetExpiration(creds.Expiration(), DefaultExpiryWindow)
+                }
+                return stsWebIdentityCreds, err
+
+        case relativeURI != "":
+                if len(endpoint) == 0 {
+                        endpoint = fmt.Sprintf("%s%s", DefaultECSRoleEndpoint, relativeURI)
+                }
+
+                roleCreds, err = getEcsTaskCredentials(m.Client, endpoint, token)
+
+        case fullURI != "":
+                if len(endpoint) == 0 {
+                        endpoint = fullURI
+                        var ok bool
+                        if ok, err = isLoopback(endpoint); !ok {
+                                if err == nil {
+                                        err = fmt.Errorf("uri host is not a loopback address: %s", endpoint)
+                                }
+                                break
+                        }
+                }
+
+                roleCreds, err = getEcsTaskCredentials(m.Client, endpoint, token)
+
+        default:
+                roleCreds, err = getCredentials(m.Client, endpoint)
+        }
+
+        if err != nil {
+                return Value{}, err
+        }
+        // Expiry window is set to 10secs.
+        m.SetExpiration(roleCreds.Expiration, DefaultExpiryWindow)
+
+        return Value{
+                AccessKeyID:     roleCreds.AccessKeyID,
+                SecretAccessKey: roleCreds.SecretAccessKey,
+                SessionToken:    roleCreds.Token,
+                SignerType:      SignatureV4,
+        }, nil
+}
+
+// A ec2RoleCredRespBody provides the shape for unmarshaling credential
+// request responses.
+type ec2RoleCredRespBody struct {
+        // Success State
+        Expiration      time.Time
+        AccessKeyID     string
+        SecretAccessKey string
+        Token           string
+
+        // Error state
+        Code    string
+        Message string
+
+        // Unused params.
+        LastUpdated time.Time
+        Type        string
+}
+
+// Get the final IAM role URL where the request will
+// be sent to fetch the rolling access credentials.
+// http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html
+func getIAMRoleURL(endpoint string) (*url.URL, error) {
+        u, err := url.Parse(endpoint)
+        if err != nil {
+                return nil, err
+        }
+        u.Path = DefaultIAMSecurityCredsPath
+        return u, nil
+}
+
+// listRoleNames lists of credential role names associated
+// with the current EC2 service. If there are no credentials,
+// or there is an error making or receiving the request.
+// http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html
+func listRoleNames(client *http.Client, u *url.URL, token string) ([]string, error) {
+        req, err := http.NewRequest(http.MethodGet, u.String(), nil)
+        if err != nil {
+                return nil, err
+        }
+        if token != "" {
+                req.Header.Add(TokenRequestHeader, token)
+        }
+        resp, err := client.Do(req)
+        if err != nil {
+                return nil, err
+        }
+        defer resp.Body.Close()
+        if resp.StatusCode != http.StatusOK {
+                return nil, errors.New(resp.Status)
+        }
+
+        credsList := []string{}
+        s := bufio.NewScanner(resp.Body)
+        for s.Scan() {
+                credsList = append(credsList, s.Text())
+        }
+
+        if err := s.Err(); err != nil {
+                return nil, err
+        }
+
+        return credsList, nil
+}
+
+func getEcsTaskCredentials(client *http.Client, endpoint, token string) (ec2RoleCredRespBody, error) {
+        req, err := http.NewRequest(http.MethodGet, endpoint, nil)
+        if err != nil {
+                return ec2RoleCredRespBody{}, err
+        }
+
+        if token != "" {
+                req.Header.Set("Authorization", token)
+        }
+
+        resp, err := client.Do(req)
+        if err != nil {
+                return ec2RoleCredRespBody{}, err
+        }
+        defer resp.Body.Close()
+        if resp.StatusCode != http.StatusOK {
+                return ec2RoleCredRespBody{}, errors.New(resp.Status)
+        }
+
+        respCreds := ec2RoleCredRespBody{}
+        if err := jsoniter.NewDecoder(resp.Body).Decode(&respCreds); err != nil {
+                return ec2RoleCredRespBody{}, err
+        }
+
+        return respCreds, nil
+}
+
+func fetchIMDSToken(client *http.Client, endpoint string) (string, error) {
+        ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+        defer cancel()
+
+        req, err := http.NewRequestWithContext(ctx, http.MethodPut, endpoint+TokenPath, nil)
+        if err != nil {
+                return "", err
+        }
+        req.Header.Add(TokenRequestTTLHeader, TokenTTL)
+        resp, err := client.Do(req)
+        if err != nil {
+                return "", err
+        }
+        defer resp.Body.Close()
+        data, err := io.ReadAll(resp.Body)
+        if err != nil {
+                return "", err
+        }
+        if resp.StatusCode != http.StatusOK {
+                return "", errors.New(resp.Status)
+        }
+        return string(data), nil
+}
+
+// getCredentials - obtains the credentials from the IAM role name associated with
+// the current EC2 service.
+//
+// If the credentials cannot be found, or there is an error
+// reading the response an error will be returned.
+func getCredentials(client *http.Client, endpoint string) (ec2RoleCredRespBody, error) {
+        if endpoint == "" {
+                endpoint = DefaultIAMRoleEndpoint
+        }
+
+        // https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html
+        token, err := fetchIMDSToken(client, endpoint)
+        if err != nil {
+                // Return only errors for valid situations, if the IMDSv2 is not enabled
+                // we will not be able to get the token, in such a situation we have
+                // to rely on IMDSv1 behavior as a fallback, this check ensures that.
+                // Refer https://github.com/minio/minio-go/issues/1866
+                if !errors.Is(err, context.DeadlineExceeded) && !errors.Is(err, context.Canceled) {
+                        return ec2RoleCredRespBody{}, err
+                }
+        }
+
+        // http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html
+        u, err := getIAMRoleURL(endpoint)
+        if err != nil {
+                return ec2RoleCredRespBody{}, err
+        }
+
+        // http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html
+        roleNames, err := listRoleNames(client, u, token)
+        if err != nil {
+                return ec2RoleCredRespBody{}, err
+        }
+
+        if len(roleNames) == 0 {
+                return ec2RoleCredRespBody{}, errors.New("No IAM roles attached to this EC2 service")
+        }
+
+        // http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html
+        // - An instance profile can contain only one IAM role. This limit cannot be increased.
+        roleName := roleNames[0]
+
+        // http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html
+        // The following command retrieves the security credentials for an
+        // IAM role named `s3access`.
+        //
+        //    $ curl http://169.254.169.254/latest/meta-data/iam/security-credentials/s3access
+        //
+        u.Path = path.Join(u.Path, roleName)
+        req, err := http.NewRequest(http.MethodGet, u.String(), nil)
+        if err != nil {
+                return ec2RoleCredRespBody{}, err
+        }
+        if token != "" {
+                req.Header.Add(TokenRequestHeader, token)
+        }
+
+        resp, err := client.Do(req)
+        if err != nil {
+                return ec2RoleCredRespBody{}, err
+        }
+        defer resp.Body.Close()
+        if resp.StatusCode != http.StatusOK {
+                return ec2RoleCredRespBody{}, errors.New(resp.Status)
+        }
+
+        respCreds := ec2RoleCredRespBody{}
+        if err := jsoniter.NewDecoder(resp.Body).Decode(&respCreds); err != nil {
+                return ec2RoleCredRespBody{}, err
+        }
+
+        if respCreds.Code != "Success" {
+                // If an error code was returned something failed requesting the role.
+                return ec2RoleCredRespBody{}, errors.New(respCreds.Message)
+        }
+
+        return respCreds, nil
+}
+
+// isLoopback identifies if a uri's host is on a loopback address
+func isLoopback(uri string) (bool, error) {
+        u, err := url.Parse(uri)
+        if err != nil {
+                return false, err
+        }
+
+        host := u.Hostname()
+        if len(host) == 0 {
+                return false, fmt.Errorf("can't parse host from uri: %s", uri)
+        }
+
+        ips, err := net.LookupHost(host)
+        if err != nil {
+                return false, err
+        }
+        for _, ip := range ips {
+                if !net.ParseIP(ip).IsLoopback() {
+                        return false, nil
+                }
+        }
+
+        return true, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/signature_type.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/signature_type.go
new file mode 100644
index 0000000..b794333
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/signature_type.go
@@ -0,0 +1,77 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 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 credentials
+
+import "strings"
+
+// SignatureType is type of Authorization requested for a given HTTP request.
+type SignatureType int
+
+// Different types of supported signatures - default is SignatureV4 or SignatureDefault.
+const (
+        // SignatureDefault is always set to v4.
+        SignatureDefault SignatureType = iota
+        SignatureV4
+        SignatureV2
+        SignatureV4Streaming
+        SignatureAnonymous // Anonymous signature signifies, no signature.
+)
+
+// IsV2 - is signature SignatureV2?
+func (s SignatureType) IsV2() bool {
+        return s == SignatureV2
+}
+
+// IsV4 - is signature SignatureV4?
+func (s SignatureType) IsV4() bool {
+        return s == SignatureV4 || s == SignatureDefault
+}
+
+// IsStreamingV4 - is signature SignatureV4Streaming?
+func (s SignatureType) IsStreamingV4() bool {
+        return s == SignatureV4Streaming
+}
+
+// IsAnonymous - is signature empty?
+func (s SignatureType) IsAnonymous() bool {
+        return s == SignatureAnonymous
+}
+
+// Stringer humanized version of signature type,
+// strings returned here are case insensitive.
+func (s SignatureType) String() string {
+        if s.IsV2() {
+                return "S3v2"
+        } else if s.IsV4() {
+                return "S3v4"
+        } else if s.IsStreamingV4() {
+                return "S3v4Streaming"
+        }
+        return "Anonymous"
+}
+
+func parseSignatureType(str string) SignatureType {
+        if strings.EqualFold(str, "S3v4") {
+                return SignatureV4
+        } else if strings.EqualFold(str, "S3v2") {
+                return SignatureV2
+        } else if strings.EqualFold(str, "S3v4Streaming") {
+                return SignatureV4Streaming
+        }
+        return SignatureAnonymous
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/static.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/static.go
new file mode 100644
index 0000000..7dde00b
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/static.go
@@ -0,0 +1,67 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 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 credentials
+
+// A Static is a set of credentials which are set programmatically,
+// and will never expire.
+type Static struct {
+        Value
+}
+
+// NewStaticV2 returns a pointer to a new Credentials object
+// wrapping a static credentials value provider, signature is
+// set to v2. If access and secret are not specified then
+// regardless of signature type set it Value will return
+// as anonymous.
+func NewStaticV2(id, secret, token string) *Credentials {
+        return NewStatic(id, secret, token, SignatureV2)
+}
+
+// NewStaticV4 is similar to NewStaticV2 with similar considerations.
+func NewStaticV4(id, secret, token string) *Credentials {
+        return NewStatic(id, secret, token, SignatureV4)
+}
+
+// NewStatic returns a pointer to a new Credentials object
+// wrapping a static credentials value provider.
+func NewStatic(id, secret, token string, signerType SignatureType) *Credentials {
+        return New(&Static{
+                Value: Value{
+                        AccessKeyID:     id,
+                        SecretAccessKey: secret,
+                        SessionToken:    token,
+                        SignerType:      signerType,
+                },
+        })
+}
+
+// Retrieve returns the static credentials.
+func (s *Static) Retrieve() (Value, error) {
+        if s.AccessKeyID == "" || s.SecretAccessKey == "" {
+                // Anonymous is not an error
+                return Value{SignerType: SignatureAnonymous}, nil
+        }
+        return s.Value, nil
+}
+
+// IsExpired returns if the credentials are expired.
+//
+// For Static, the credentials never expired.
+func (s *Static) IsExpired() bool {
+        return false
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_client_grants.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_client_grants.go
new file mode 100644
index 0000000..9e92c1e
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_client_grants.go
@@ -0,0 +1,182 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2019-2022 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 credentials
+
+import (
+        "bytes"
+        "encoding/xml"
+        "errors"
+        "fmt"
+        "io"
+        "net/http"
+        "net/url"
+        "strings"
+        "time"
+)
+
+// AssumedRoleUser - The identifiers for the temporary security credentials that
+// the operation returns. Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumedRoleUser
+type AssumedRoleUser struct {
+        Arn           string
+        AssumedRoleID string `xml:"AssumeRoleId"`
+}
+
+// AssumeRoleWithClientGrantsResponse contains the result of successful AssumeRoleWithClientGrants request.
+type AssumeRoleWithClientGrantsResponse struct {
+        XMLName          xml.Name           `xml:"https://sts.amazonaws.com/doc/2011-06-15/ AssumeRoleWithClientGrantsResponse" json:"-"`
+        Result           ClientGrantsResult `xml:"AssumeRoleWithClientGrantsResult"`
+        ResponseMetadata struct {
+                RequestID string `xml:"RequestId,omitempty"`
+        } `xml:"ResponseMetadata,omitempty"`
+}
+
+// ClientGrantsResult - Contains the response to a successful AssumeRoleWithClientGrants
+// request, including temporary credentials that can be used to make MinIO API requests.
+type ClientGrantsResult struct {
+        AssumedRoleUser AssumedRoleUser `xml:",omitempty"`
+        Audience        string          `xml:",omitempty"`
+        Credentials     struct {
+                AccessKey    string    `xml:"AccessKeyId" json:"accessKey,omitempty"`
+                SecretKey    string    `xml:"SecretAccessKey" json:"secretKey,omitempty"`
+                Expiration   time.Time `xml:"Expiration" json:"expiration,omitempty"`
+                SessionToken string    `xml:"SessionToken" json:"sessionToken,omitempty"`
+        } `xml:",omitempty"`
+        PackedPolicySize             int    `xml:",omitempty"`
+        Provider                     string `xml:",omitempty"`
+        SubjectFromClientGrantsToken string `xml:",omitempty"`
+}
+
+// ClientGrantsToken - client grants token with expiry.
+type ClientGrantsToken struct {
+        Token  string
+        Expiry int
+}
+
+// A STSClientGrants retrieves credentials from MinIO service, and keeps track if
+// those credentials are expired.
+type STSClientGrants struct {
+        Expiry
+
+        // Required http Client to use when connecting to MinIO STS service.
+        Client *http.Client
+
+        // MinIO endpoint to fetch STS credentials.
+        STSEndpoint string
+
+        // getClientGrantsTokenExpiry function to retrieve tokens
+        // from IDP This function should return two values one is
+        // accessToken which is a self contained access token (JWT)
+        // and second return value is the expiry associated with
+        // this token. This is a customer provided function and
+        // is mandatory.
+        GetClientGrantsTokenExpiry func() (*ClientGrantsToken, error)
+}
+
+// NewSTSClientGrants returns a pointer to a new
+// Credentials object wrapping the STSClientGrants.
+func NewSTSClientGrants(stsEndpoint string, getClientGrantsTokenExpiry func() (*ClientGrantsToken, error)) (*Credentials, error) {
+        if stsEndpoint == "" {
+                return nil, errors.New("STS endpoint cannot be empty")
+        }
+        if getClientGrantsTokenExpiry == nil {
+                return nil, errors.New("Client grants access token and expiry retrieval function should be defined")
+        }
+        return New(&STSClientGrants{
+                Client: &http.Client{
+                        Transport: http.DefaultTransport,
+                },
+                STSEndpoint:                stsEndpoint,
+                GetClientGrantsTokenExpiry: getClientGrantsTokenExpiry,
+        }), nil
+}
+
+func getClientGrantsCredentials(clnt *http.Client, endpoint string,
+        getClientGrantsTokenExpiry func() (*ClientGrantsToken, error),
+) (AssumeRoleWithClientGrantsResponse, error) {
+        accessToken, err := getClientGrantsTokenExpiry()
+        if err != nil {
+                return AssumeRoleWithClientGrantsResponse{}, err
+        }
+
+        v := url.Values{}
+        v.Set("Action", "AssumeRoleWithClientGrants")
+        v.Set("Token", accessToken.Token)
+        v.Set("DurationSeconds", fmt.Sprintf("%d", accessToken.Expiry))
+        v.Set("Version", STSVersion)
+
+        u, err := url.Parse(endpoint)
+        if err != nil {
+                return AssumeRoleWithClientGrantsResponse{}, err
+        }
+
+        req, err := http.NewRequest(http.MethodPost, u.String(), strings.NewReader(v.Encode()))
+        if err != nil {
+                return AssumeRoleWithClientGrantsResponse{}, err
+        }
+
+        req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+        resp, err := clnt.Do(req)
+        if err != nil {
+                return AssumeRoleWithClientGrantsResponse{}, err
+        }
+        defer resp.Body.Close()
+        if resp.StatusCode != http.StatusOK {
+                var errResp ErrorResponse
+                buf, err := io.ReadAll(resp.Body)
+                if err != nil {
+                        return AssumeRoleWithClientGrantsResponse{}, err
+                }
+                _, err = xmlDecodeAndBody(bytes.NewReader(buf), &errResp)
+                if err != nil {
+                        var s3Err Error
+                        if _, err = xmlDecodeAndBody(bytes.NewReader(buf), &s3Err); err != nil {
+                                return AssumeRoleWithClientGrantsResponse{}, err
+                        }
+                        errResp.RequestID = s3Err.RequestID
+                        errResp.STSError.Code = s3Err.Code
+                        errResp.STSError.Message = s3Err.Message
+                }
+                return AssumeRoleWithClientGrantsResponse{}, errResp
+        }
+
+        a := AssumeRoleWithClientGrantsResponse{}
+        if err = xml.NewDecoder(resp.Body).Decode(&a); err != nil {
+                return AssumeRoleWithClientGrantsResponse{}, err
+        }
+        return a, nil
+}
+
+// Retrieve retrieves credentials from the MinIO service.
+// Error will be returned if the request fails.
+func (m *STSClientGrants) Retrieve() (Value, error) {
+        a, err := getClientGrantsCredentials(m.Client, m.STSEndpoint, m.GetClientGrantsTokenExpiry)
+        if err != nil {
+                return Value{}, err
+        }
+
+        // Expiry window is set to 10secs.
+        m.SetExpiration(a.Result.Credentials.Expiration, DefaultExpiryWindow)
+
+        return Value{
+                AccessKeyID:     a.Result.Credentials.AccessKey,
+                SecretAccessKey: a.Result.Credentials.SecretKey,
+                SessionToken:    a.Result.Credentials.SessionToken,
+                SignerType:      SignatureV4,
+        }, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_custom_identity.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_custom_identity.go
new file mode 100644
index 0000000..e1f9ce4
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_custom_identity.go
@@ -0,0 +1,146 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2022 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 credentials
+
+import (
+        "encoding/xml"
+        "errors"
+        "fmt"
+        "net/http"
+        "net/url"
+        "time"
+)
+
+// CustomTokenResult - Contains temporary creds and user metadata.
+type CustomTokenResult struct {
+        Credentials struct {
+                AccessKey    string    `xml:"AccessKeyId"`
+                SecretKey    string    `xml:"SecretAccessKey"`
+                Expiration   time.Time `xml:"Expiration"`
+                SessionToken string    `xml:"SessionToken"`
+        } `xml:",omitempty"`
+
+        AssumedUser string `xml:",omitempty"`
+}
+
+// AssumeRoleWithCustomTokenResponse contains the result of a successful
+// AssumeRoleWithCustomToken request.
+type AssumeRoleWithCustomTokenResponse struct {
+        XMLName  xml.Name          `xml:"https://sts.amazonaws.com/doc/2011-06-15/ AssumeRoleWithCustomTokenResponse" json:"-"`
+        Result   CustomTokenResult `xml:"AssumeRoleWithCustomTokenResult"`
+        Metadata struct {
+                RequestID string `xml:"RequestId,omitempty"`
+        } `xml:"ResponseMetadata,omitempty"`
+}
+
+// CustomTokenIdentity - satisfies the Provider interface, and retrieves
+// credentials from MinIO using the AssumeRoleWithCustomToken STS API.
+type CustomTokenIdentity struct {
+        Expiry
+
+        Client *http.Client
+
+        // MinIO server STS endpoint to fetch STS credentials.
+        STSEndpoint string
+
+        // The custom token to use with the request.
+        Token string
+
+        // RoleArn associated with the identity
+        RoleArn string
+
+        // RequestedExpiry is to set the validity of the generated credentials
+        // (this value bounded by server).
+        RequestedExpiry time.Duration
+}
+
+// Retrieve - to satisfy Provider interface; fetches credentials from MinIO.
+func (c *CustomTokenIdentity) Retrieve() (value Value, err error) {
+        u, err := url.Parse(c.STSEndpoint)
+        if err != nil {
+                return value, err
+        }
+
+        v := url.Values{}
+        v.Set("Action", "AssumeRoleWithCustomToken")
+        v.Set("Version", STSVersion)
+        v.Set("RoleArn", c.RoleArn)
+        v.Set("Token", c.Token)
+        if c.RequestedExpiry != 0 {
+                v.Set("DurationSeconds", fmt.Sprintf("%d", int(c.RequestedExpiry.Seconds())))
+        }
+
+        u.RawQuery = v.Encode()
+
+        req, err := http.NewRequest(http.MethodPost, u.String(), nil)
+        if err != nil {
+                return value, err
+        }
+
+        resp, err := c.Client.Do(req)
+        if err != nil {
+                return value, err
+        }
+
+        defer resp.Body.Close()
+        if resp.StatusCode != http.StatusOK {
+                return value, errors.New(resp.Status)
+        }
+
+        r := AssumeRoleWithCustomTokenResponse{}
+        if err = xml.NewDecoder(resp.Body).Decode(&r); err != nil {
+                return
+        }
+
+        cr := r.Result.Credentials
+        c.SetExpiration(cr.Expiration, DefaultExpiryWindow)
+        return Value{
+                AccessKeyID:     cr.AccessKey,
+                SecretAccessKey: cr.SecretKey,
+                SessionToken:    cr.SessionToken,
+                SignerType:      SignatureV4,
+        }, nil
+}
+
+// NewCustomTokenCredentials - returns credentials using the
+// AssumeRoleWithCustomToken STS API.
+func NewCustomTokenCredentials(stsEndpoint, token, roleArn string, optFuncs ...CustomTokenOpt) (*Credentials, error) {
+        c := CustomTokenIdentity{
+                Client:      &http.Client{Transport: http.DefaultTransport},
+                STSEndpoint: stsEndpoint,
+                Token:       token,
+                RoleArn:     roleArn,
+        }
+        for _, optFunc := range optFuncs {
+                optFunc(&c)
+        }
+        return New(&c), nil
+}
+
+// CustomTokenOpt is a function type to configure the custom-token based
+// credentials using NewCustomTokenCredentials.
+type CustomTokenOpt func(*CustomTokenIdentity)
+
+// CustomTokenValidityOpt sets the validity duration of the requested
+// credentials. This value is ignored if the server enforces a lower validity
+// period.
+func CustomTokenValidityOpt(d time.Duration) CustomTokenOpt {
+        return func(c *CustomTokenIdentity) {
+                c.RequestedExpiry = d
+        }
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_ldap_identity.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_ldap_identity.go
new file mode 100644
index 0000000..ec5f3f0
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_ldap_identity.go
@@ -0,0 +1,189 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2019-2022 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 credentials
+
+import (
+        "bytes"
+        "encoding/xml"
+        "fmt"
+        "io"
+        "net/http"
+        "net/url"
+        "strings"
+        "time"
+)
+
+// AssumeRoleWithLDAPResponse contains the result of successful
+// AssumeRoleWithLDAPIdentity request
+type AssumeRoleWithLDAPResponse struct {
+        XMLName          xml.Name           `xml:"https://sts.amazonaws.com/doc/2011-06-15/ AssumeRoleWithLDAPIdentityResponse" json:"-"`
+        Result           LDAPIdentityResult `xml:"AssumeRoleWithLDAPIdentityResult"`
+        ResponseMetadata struct {
+                RequestID string `xml:"RequestId,omitempty"`
+        } `xml:"ResponseMetadata,omitempty"`
+}
+
+// LDAPIdentityResult - contains credentials for a successful
+// AssumeRoleWithLDAPIdentity request.
+type LDAPIdentityResult struct {
+        Credentials struct {
+                AccessKey    string    `xml:"AccessKeyId" json:"accessKey,omitempty"`
+                SecretKey    string    `xml:"SecretAccessKey" json:"secretKey,omitempty"`
+                Expiration   time.Time `xml:"Expiration" json:"expiration,omitempty"`
+                SessionToken string    `xml:"SessionToken" json:"sessionToken,omitempty"`
+        } `xml:",omitempty"`
+
+        SubjectFromToken string `xml:",omitempty"`
+}
+
+// LDAPIdentity retrieves credentials from MinIO
+type LDAPIdentity struct {
+        Expiry
+
+        // Required http Client to use when connecting to MinIO STS service.
+        Client *http.Client
+
+        // Exported STS endpoint to fetch STS credentials.
+        STSEndpoint string
+
+        // LDAP username/password used to fetch LDAP STS credentials.
+        LDAPUsername, LDAPPassword string
+
+        // Session policy to apply to the generated credentials. Leave empty to
+        // use the full access policy available to the user.
+        Policy string
+
+        // RequestedExpiry is the configured expiry duration for credentials
+        // requested from LDAP.
+        RequestedExpiry time.Duration
+}
+
+// NewLDAPIdentity returns new credentials object that uses LDAP
+// Identity.
+func NewLDAPIdentity(stsEndpoint, ldapUsername, ldapPassword string, optFuncs ...LDAPIdentityOpt) (*Credentials, error) {
+        l := LDAPIdentity{
+                Client:       &http.Client{Transport: http.DefaultTransport},
+                STSEndpoint:  stsEndpoint,
+                LDAPUsername: ldapUsername,
+                LDAPPassword: ldapPassword,
+        }
+        for _, optFunc := range optFuncs {
+                optFunc(&l)
+        }
+        return New(&l), nil
+}
+
+// LDAPIdentityOpt is a function type used to configured the LDAPIdentity
+// instance.
+type LDAPIdentityOpt func(*LDAPIdentity)
+
+// LDAPIdentityPolicyOpt sets the session policy for requested credentials.
+func LDAPIdentityPolicyOpt(policy string) LDAPIdentityOpt {
+        return func(k *LDAPIdentity) {
+                k.Policy = policy
+        }
+}
+
+// LDAPIdentityExpiryOpt sets the expiry duration for requested credentials.
+func LDAPIdentityExpiryOpt(d time.Duration) LDAPIdentityOpt {
+        return func(k *LDAPIdentity) {
+                k.RequestedExpiry = d
+        }
+}
+
+// NewLDAPIdentityWithSessionPolicy returns new credentials object that uses
+// LDAP Identity with a specified session policy. The `policy` parameter must be
+// a JSON string specifying the policy document.
+//
+// Deprecated: Use the `LDAPIdentityPolicyOpt` with `NewLDAPIdentity` instead.
+func NewLDAPIdentityWithSessionPolicy(stsEndpoint, ldapUsername, ldapPassword, policy string) (*Credentials, error) {
+        return New(&LDAPIdentity{
+                Client:       &http.Client{Transport: http.DefaultTransport},
+                STSEndpoint:  stsEndpoint,
+                LDAPUsername: ldapUsername,
+                LDAPPassword: ldapPassword,
+                Policy:       policy,
+        }), nil
+}
+
+// Retrieve gets the credential by calling the MinIO STS API for
+// LDAP on the configured stsEndpoint.
+func (k *LDAPIdentity) Retrieve() (value Value, err error) {
+        u, err := url.Parse(k.STSEndpoint)
+        if err != nil {
+                return value, err
+        }
+
+        v := url.Values{}
+        v.Set("Action", "AssumeRoleWithLDAPIdentity")
+        v.Set("Version", STSVersion)
+        v.Set("LDAPUsername", k.LDAPUsername)
+        v.Set("LDAPPassword", k.LDAPPassword)
+        if k.Policy != "" {
+                v.Set("Policy", k.Policy)
+        }
+        if k.RequestedExpiry != 0 {
+                v.Set("DurationSeconds", fmt.Sprintf("%d", int(k.RequestedExpiry.Seconds())))
+        }
+
+        req, err := http.NewRequest(http.MethodPost, u.String(), strings.NewReader(v.Encode()))
+        if err != nil {
+                return value, err
+        }
+
+        req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+        resp, err := k.Client.Do(req)
+        if err != nil {
+                return value, err
+        }
+
+        defer resp.Body.Close()
+        if resp.StatusCode != http.StatusOK {
+                var errResp ErrorResponse
+                buf, err := io.ReadAll(resp.Body)
+                if err != nil {
+                        return value, err
+                }
+                _, err = xmlDecodeAndBody(bytes.NewReader(buf), &errResp)
+                if err != nil {
+                        var s3Err Error
+                        if _, err = xmlDecodeAndBody(bytes.NewReader(buf), &s3Err); err != nil {
+                                return value, err
+                        }
+                        errResp.RequestID = s3Err.RequestID
+                        errResp.STSError.Code = s3Err.Code
+                        errResp.STSError.Message = s3Err.Message
+                }
+                return value, errResp
+        }
+
+        r := AssumeRoleWithLDAPResponse{}
+        if err = xml.NewDecoder(resp.Body).Decode(&r); err != nil {
+                return
+        }
+
+        cr := r.Result.Credentials
+        k.SetExpiration(cr.Expiration, DefaultExpiryWindow)
+        return Value{
+                AccessKeyID:     cr.AccessKey,
+                SecretAccessKey: cr.SecretKey,
+                SessionToken:    cr.SessionToken,
+                SignerType:      SignatureV4,
+        }, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_tls_identity.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_tls_identity.go
new file mode 100644
index 0000000..dee0a8c
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_tls_identity.go
@@ -0,0 +1,211 @@
+// MinIO Go Library for Amazon S3 Compatible Cloud Storage
+// Copyright 2021 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 credentials
+
+import (
+        "bytes"
+        "crypto/tls"
+        "encoding/xml"
+        "errors"
+        "io"
+        "net"
+        "net/http"
+        "net/url"
+        "strconv"
+        "time"
+)
+
+// CertificateIdentityOption is an optional AssumeRoleWithCertificate
+// parameter - e.g. a custom HTTP transport configuration or S3 credental
+// livetime.
+type CertificateIdentityOption func(*STSCertificateIdentity)
+
+// CertificateIdentityWithTransport returns a CertificateIdentityOption that
+// customizes the STSCertificateIdentity with the given http.RoundTripper.
+func CertificateIdentityWithTransport(t http.RoundTripper) CertificateIdentityOption {
+        return CertificateIdentityOption(func(i *STSCertificateIdentity) { i.Client.Transport = t })
+}
+
+// CertificateIdentityWithExpiry returns a CertificateIdentityOption that
+// customizes the STSCertificateIdentity with the given livetime.
+//
+// Fetched S3 credentials will have the given livetime if the STS server
+// allows such credentials.
+func CertificateIdentityWithExpiry(livetime time.Duration) CertificateIdentityOption {
+        return CertificateIdentityOption(func(i *STSCertificateIdentity) { i.S3CredentialLivetime = livetime })
+}
+
+// A STSCertificateIdentity retrieves S3 credentials from the MinIO STS API and
+// rotates those credentials once they expire.
+type STSCertificateIdentity struct {
+        Expiry
+
+        // STSEndpoint is the base URL endpoint of the STS API.
+        // For example, https://minio.local:9000
+        STSEndpoint string
+
+        // S3CredentialLivetime is the duration temp. S3 access
+        // credentials should be valid.
+        //
+        // It represents the access credential livetime requested
+        // by the client. The STS server may choose to issue
+        // temp. S3 credentials that have a different - usually
+        // shorter - livetime.
+        //
+        // The default livetime is one hour.
+        S3CredentialLivetime time.Duration
+
+        // Client is the HTTP client used to authenticate and fetch
+        // S3 credentials.
+        //
+        // A custom TLS client configuration can be specified by
+        // using a custom http.Transport:
+        //   Client: http.Client {
+        //       Transport: &http.Transport{
+        //           TLSClientConfig: &tls.Config{},
+        //       },
+        //   }
+        Client http.Client
+}
+
+var _ Provider = (*STSWebIdentity)(nil) // compiler check
+
+// NewSTSCertificateIdentity returns a STSCertificateIdentity that authenticates
+// to the given STS endpoint with the given TLS certificate and retrieves and
+// rotates S3 credentials.
+func NewSTSCertificateIdentity(endpoint string, certificate tls.Certificate, options ...CertificateIdentityOption) (*Credentials, error) {
+        if endpoint == "" {
+                return nil, errors.New("STS endpoint cannot be empty")
+        }
+        if _, err := url.Parse(endpoint); err != nil {
+                return nil, err
+        }
+        identity := &STSCertificateIdentity{
+                STSEndpoint: endpoint,
+                Client: http.Client{
+                        Transport: &http.Transport{
+                                Proxy: http.ProxyFromEnvironment,
+                                DialContext: (&net.Dialer{
+                                        Timeout:   30 * time.Second,
+                                        KeepAlive: 30 * time.Second,
+                                }).DialContext,
+                                ForceAttemptHTTP2:     true,
+                                MaxIdleConns:          100,
+                                IdleConnTimeout:       90 * time.Second,
+                                TLSHandshakeTimeout:   10 * time.Second,
+                                ExpectContinueTimeout: 5 * time.Second,
+                                TLSClientConfig: &tls.Config{
+                                        Certificates: []tls.Certificate{certificate},
+                                },
+                        },
+                },
+        }
+        for _, option := range options {
+                option(identity)
+        }
+        return New(identity), nil
+}
+
+// Retrieve fetches a new set of S3 credentials from the configured
+// STS API endpoint.
+func (i *STSCertificateIdentity) Retrieve() (Value, error) {
+        endpointURL, err := url.Parse(i.STSEndpoint)
+        if err != nil {
+                return Value{}, err
+        }
+        livetime := i.S3CredentialLivetime
+        if livetime == 0 {
+                livetime = 1 * time.Hour
+        }
+
+        queryValues := url.Values{}
+        queryValues.Set("Action", "AssumeRoleWithCertificate")
+        queryValues.Set("Version", STSVersion)
+        endpointURL.RawQuery = queryValues.Encode()
+
+        req, err := http.NewRequest(http.MethodPost, endpointURL.String(), nil)
+        if err != nil {
+                return Value{}, err
+        }
+        if req.Form == nil {
+                req.Form = url.Values{}
+        }
+        req.Form.Add("DurationSeconds", strconv.FormatUint(uint64(livetime.Seconds()), 10))
+
+        resp, err := i.Client.Do(req)
+        if err != nil {
+                return Value{}, err
+        }
+        if resp.Body != nil {
+                defer resp.Body.Close()
+        }
+        if resp.StatusCode != http.StatusOK {
+                var errResp ErrorResponse
+                buf, err := io.ReadAll(resp.Body)
+                if err != nil {
+                        return Value{}, err
+                }
+                _, err = xmlDecodeAndBody(bytes.NewReader(buf), &errResp)
+                if err != nil {
+                        var s3Err Error
+                        if _, err = xmlDecodeAndBody(bytes.NewReader(buf), &s3Err); err != nil {
+                                return Value{}, err
+                        }
+                        errResp.RequestID = s3Err.RequestID
+                        errResp.STSError.Code = s3Err.Code
+                        errResp.STSError.Message = s3Err.Message
+                }
+                return Value{}, errResp
+        }
+
+        const MaxSize = 10 * 1 << 20
+        var body io.Reader = resp.Body
+        if resp.ContentLength > 0 && resp.ContentLength < MaxSize {
+                body = io.LimitReader(body, resp.ContentLength)
+        } else {
+                body = io.LimitReader(body, MaxSize)
+        }
+
+        var response assumeRoleWithCertificateResponse
+        if err = xml.NewDecoder(body).Decode(&response); err != nil {
+                return Value{}, err
+        }
+        i.SetExpiration(response.Result.Credentials.Expiration, DefaultExpiryWindow)
+        return Value{
+                AccessKeyID:     response.Result.Credentials.AccessKey,
+                SecretAccessKey: response.Result.Credentials.SecretKey,
+                SessionToken:    response.Result.Credentials.SessionToken,
+                SignerType:      SignatureDefault,
+        }, nil
+}
+
+// Expiration returns the expiration time of the current S3 credentials.
+func (i *STSCertificateIdentity) Expiration() time.Time { return i.expiration }
+
+type assumeRoleWithCertificateResponse struct {
+        XMLName xml.Name `xml:"https://sts.amazonaws.com/doc/2011-06-15/ AssumeRoleWithCertificateResponse" json:"-"`
+        Result  struct {
+                Credentials struct {
+                        AccessKey    string    `xml:"AccessKeyId" json:"accessKey,omitempty"`
+                        SecretKey    string    `xml:"SecretAccessKey" json:"secretKey,omitempty"`
+                        Expiration   time.Time `xml:"Expiration" json:"expiration,omitempty"`
+                        SessionToken string    `xml:"SessionToken" json:"sessionToken,omitempty"`
+                } `xml:"Credentials" json:"credentials,omitempty"`
+        } `xml:"AssumeRoleWithCertificateResult"`
+        ResponseMetadata struct {
+                RequestID string `xml:"RequestId,omitempty"`
+        } `xml:"ResponseMetadata,omitempty"`
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_web_identity.go b/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_web_identity.go
new file mode 100644
index 0000000..2e2af50
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/credentials/sts_web_identity.go
@@ -0,0 +1,205 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2019-2022 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 credentials
+
+import (
+        "bytes"
+        "encoding/xml"
+        "errors"
+        "fmt"
+        "io"
+        "net/http"
+        "net/url"
+        "strconv"
+        "strings"
+        "time"
+)
+
+// AssumeRoleWithWebIdentityResponse contains the result of successful AssumeRoleWithWebIdentity request.
+type AssumeRoleWithWebIdentityResponse struct {
+        XMLName          xml.Name          `xml:"https://sts.amazonaws.com/doc/2011-06-15/ AssumeRoleWithWebIdentityResponse" json:"-"`
+        Result           WebIdentityResult `xml:"AssumeRoleWithWebIdentityResult"`
+        ResponseMetadata struct {
+                RequestID string `xml:"RequestId,omitempty"`
+        } `xml:"ResponseMetadata,omitempty"`
+}
+
+// WebIdentityResult - Contains the response to a successful AssumeRoleWithWebIdentity
+// request, including temporary credentials that can be used to make MinIO API requests.
+type WebIdentityResult struct {
+        AssumedRoleUser AssumedRoleUser `xml:",omitempty"`
+        Audience        string          `xml:",omitempty"`
+        Credentials     struct {
+                AccessKey    string    `xml:"AccessKeyId" json:"accessKey,omitempty"`
+                SecretKey    string    `xml:"SecretAccessKey" json:"secretKey,omitempty"`
+                Expiration   time.Time `xml:"Expiration" json:"expiration,omitempty"`
+                SessionToken string    `xml:"SessionToken" json:"sessionToken,omitempty"`
+        } `xml:",omitempty"`
+        PackedPolicySize            int    `xml:",omitempty"`
+        Provider                    string `xml:",omitempty"`
+        SubjectFromWebIdentityToken string `xml:",omitempty"`
+}
+
+// WebIdentityToken - web identity token with expiry.
+type WebIdentityToken struct {
+        Token       string
+        AccessToken string
+        Expiry      int
+}
+
+// A STSWebIdentity retrieves credentials from MinIO service, and keeps track if
+// those credentials are expired.
+type STSWebIdentity struct {
+        Expiry
+
+        // Required http Client to use when connecting to MinIO STS service.
+        Client *http.Client
+
+        // Exported STS endpoint to fetch STS credentials.
+        STSEndpoint string
+
+        // Exported GetWebIDTokenExpiry function which returns ID
+        // tokens from IDP. This function should return two values
+        // one is ID token which is a self contained ID token (JWT)
+        // and second return value is the expiry associated with
+        // this token.
+        // This is a customer provided function and is mandatory.
+        GetWebIDTokenExpiry func() (*WebIdentityToken, error)
+
+        // RoleARN is the Amazon Resource Name (ARN) of the role that the caller is
+        // assuming.
+        RoleARN string
+
+        // roleSessionName is the identifier for the assumed role session.
+        roleSessionName string
+}
+
+// NewSTSWebIdentity returns a pointer to a new
+// Credentials object wrapping the STSWebIdentity.
+func NewSTSWebIdentity(stsEndpoint string, getWebIDTokenExpiry func() (*WebIdentityToken, error)) (*Credentials, error) {
+        if stsEndpoint == "" {
+                return nil, errors.New("STS endpoint cannot be empty")
+        }
+        if getWebIDTokenExpiry == nil {
+                return nil, errors.New("Web ID token and expiry retrieval function should be defined")
+        }
+        return New(&STSWebIdentity{
+                Client: &http.Client{
+                        Transport: http.DefaultTransport,
+                },
+                STSEndpoint:         stsEndpoint,
+                GetWebIDTokenExpiry: getWebIDTokenExpiry,
+        }), nil
+}
+
+func getWebIdentityCredentials(clnt *http.Client, endpoint, roleARN, roleSessionName string,
+        getWebIDTokenExpiry func() (*WebIdentityToken, error),
+) (AssumeRoleWithWebIdentityResponse, error) {
+        idToken, err := getWebIDTokenExpiry()
+        if err != nil {
+                return AssumeRoleWithWebIdentityResponse{}, err
+        }
+
+        v := url.Values{}
+        v.Set("Action", "AssumeRoleWithWebIdentity")
+        if len(roleARN) > 0 {
+                v.Set("RoleArn", roleARN)
+
+                if len(roleSessionName) == 0 {
+                        roleSessionName = strconv.FormatInt(time.Now().UnixNano(), 10)
+                }
+                v.Set("RoleSessionName", roleSessionName)
+        }
+        v.Set("WebIdentityToken", idToken.Token)
+        if idToken.AccessToken != "" {
+                // Usually set when server is using extended userInfo endpoint.
+                v.Set("WebIdentityAccessToken", idToken.AccessToken)
+        }
+        if idToken.Expiry > 0 {
+                v.Set("DurationSeconds", fmt.Sprintf("%d", idToken.Expiry))
+        }
+        v.Set("Version", STSVersion)
+
+        u, err := url.Parse(endpoint)
+        if err != nil {
+                return AssumeRoleWithWebIdentityResponse{}, err
+        }
+
+        req, err := http.NewRequest(http.MethodPost, u.String(), strings.NewReader(v.Encode()))
+        if err != nil {
+                return AssumeRoleWithWebIdentityResponse{}, err
+        }
+
+        req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+        resp, err := clnt.Do(req)
+        if err != nil {
+                return AssumeRoleWithWebIdentityResponse{}, err
+        }
+
+        defer resp.Body.Close()
+        if resp.StatusCode != http.StatusOK {
+                var errResp ErrorResponse
+                buf, err := io.ReadAll(resp.Body)
+                if err != nil {
+                        return AssumeRoleWithWebIdentityResponse{}, err
+                }
+                _, err = xmlDecodeAndBody(bytes.NewReader(buf), &errResp)
+                if err != nil {
+                        var s3Err Error
+                        if _, err = xmlDecodeAndBody(bytes.NewReader(buf), &s3Err); err != nil {
+                                return AssumeRoleWithWebIdentityResponse{}, err
+                        }
+                        errResp.RequestID = s3Err.RequestID
+                        errResp.STSError.Code = s3Err.Code
+                        errResp.STSError.Message = s3Err.Message
+                }
+                return AssumeRoleWithWebIdentityResponse{}, errResp
+        }
+
+        a := AssumeRoleWithWebIdentityResponse{}
+        if err = xml.NewDecoder(resp.Body).Decode(&a); err != nil {
+                return AssumeRoleWithWebIdentityResponse{}, err
+        }
+
+        return a, nil
+}
+
+// Retrieve retrieves credentials from the MinIO service.
+// Error will be returned if the request fails.
+func (m *STSWebIdentity) Retrieve() (Value, error) {
+        a, err := getWebIdentityCredentials(m.Client, m.STSEndpoint, m.RoleARN, m.roleSessionName, m.GetWebIDTokenExpiry)
+        if err != nil {
+                return Value{}, err
+        }
+
+        // Expiry window is set to 10secs.
+        m.SetExpiration(a.Result.Credentials.Expiration, DefaultExpiryWindow)
+
+        return Value{
+                AccessKeyID:     a.Result.Credentials.AccessKey,
+                SecretAccessKey: a.Result.Credentials.SecretKey,
+                SessionToken:    a.Result.Credentials.SessionToken,
+                SignerType:      SignatureV4,
+        }, nil
+}
+
+// Expiration returns the expiration time of the credentials
+func (m *STSWebIdentity) Expiration() time.Time {
+        return m.expiration
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/encrypt/fips_disabled.go b/vendor/github.com/minio/minio-go/v7/pkg/encrypt/fips_disabled.go
new file mode 100644
index 0000000..6db26c0
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/encrypt/fips_disabled.go
@@ -0,0 +1,24 @@
+//go:build !fips
+// +build !fips
+
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2022 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 encrypt
+
+// FIPS is true if 'fips' build tag was specified.
+const FIPS = false
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/encrypt/fips_enabled.go b/vendor/github.com/minio/minio-go/v7/pkg/encrypt/fips_enabled.go
new file mode 100644
index 0000000..6402582
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/encrypt/fips_enabled.go
@@ -0,0 +1,24 @@
+//go:build fips
+// +build fips
+
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2022 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 encrypt
+
+// FIPS is true if 'fips' build tag was specified.
+const FIPS = true
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/encrypt/server-side.go b/vendor/github.com/minio/minio-go/v7/pkg/encrypt/server-side.go
new file mode 100644
index 0000000..a7081c5
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/encrypt/server-side.go
@@ -0,0 +1,198 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2018 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 encrypt
+
+import (
+        "crypto/md5"
+        "encoding/base64"
+        "errors"
+        "net/http"
+
+        jsoniter "github.com/json-iterator/go"
+        "golang.org/x/crypto/argon2"
+)
+
+const (
+        // SseGenericHeader is the AWS SSE header used for SSE-S3 and SSE-KMS.
+        SseGenericHeader = "X-Amz-Server-Side-Encryption"
+
+        // SseKmsKeyID is the AWS SSE-KMS key id.
+        SseKmsKeyID = SseGenericHeader + "-Aws-Kms-Key-Id"
+        // SseEncryptionContext is the AWS SSE-KMS Encryption Context data.
+        SseEncryptionContext = SseGenericHeader + "-Context"
+
+        // SseCustomerAlgorithm is the AWS SSE-C algorithm HTTP header key.
+        SseCustomerAlgorithm = SseGenericHeader + "-Customer-Algorithm"
+        // SseCustomerKey is the AWS SSE-C encryption key HTTP header key.
+        SseCustomerKey = SseGenericHeader + "-Customer-Key"
+        // SseCustomerKeyMD5 is the AWS SSE-C encryption key MD5 HTTP header key.
+        SseCustomerKeyMD5 = SseGenericHeader + "-Customer-Key-MD5"
+
+        // SseCopyCustomerAlgorithm is the AWS SSE-C algorithm HTTP header key for CopyObject API.
+        SseCopyCustomerAlgorithm = "X-Amz-Copy-Source-Server-Side-Encryption-Customer-Algorithm"
+        // SseCopyCustomerKey is the AWS SSE-C encryption key HTTP header key for CopyObject API.
+        SseCopyCustomerKey = "X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key"
+        // SseCopyCustomerKeyMD5 is the AWS SSE-C encryption key MD5 HTTP header key for CopyObject API.
+        SseCopyCustomerKeyMD5 = "X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key-MD5"
+)
+
+// PBKDF creates a SSE-C key from the provided password and salt.
+// PBKDF is a password-based key derivation function
+// which can be used to derive a high-entropy cryptographic
+// key from a low-entropy password and a salt.
+type PBKDF func(password, salt []byte) ServerSide
+
+// DefaultPBKDF is the default PBKDF. It uses Argon2id with the
+// recommended parameters from the RFC draft (1 pass, 64 MB memory, 4 threads).
+var DefaultPBKDF PBKDF = func(password, salt []byte) ServerSide {
+        sse := ssec{}
+        copy(sse[:], argon2.IDKey(password, salt, 1, 64*1024, 4, 32))
+        return sse
+}
+
+// Type is the server-side-encryption method. It represents one of
+// the following encryption methods:
+//   - SSE-C: server-side-encryption with customer provided keys
+//   - KMS:   server-side-encryption with managed keys
+//   - S3:    server-side-encryption using S3 storage encryption
+type Type string
+
+const (
+        // SSEC represents server-side-encryption with customer provided keys
+        SSEC Type = "SSE-C"
+        // KMS represents server-side-encryption with managed keys
+        KMS Type = "KMS"
+        // S3 represents server-side-encryption using S3 storage encryption
+        S3 Type = "S3"
+)
+
+// ServerSide is a form of S3 server-side-encryption.
+type ServerSide interface {
+        // Type returns the server-side-encryption method.
+        Type() Type
+
+        // Marshal adds encryption headers to the provided HTTP headers.
+        // It marks an HTTP request as server-side-encryption request
+        // and inserts the required data into the headers.
+        Marshal(h http.Header)
+}
+
+// NewSSE returns a server-side-encryption using S3 storage encryption.
+// Using SSE-S3 the server will encrypt the object with server-managed keys.
+func NewSSE() ServerSide { return s3{} }
+
+// NewSSEKMS returns a new server-side-encryption using SSE-KMS and the provided Key Id and context.
+func NewSSEKMS(keyID string, context interface{}) (ServerSide, error) {
+        if context == nil {
+                return kms{key: keyID, hasContext: false}, nil
+        }
+        json := jsoniter.ConfigCompatibleWithStandardLibrary
+        serializedContext, err := json.Marshal(context)
+        if err != nil {
+                return nil, err
+        }
+        return kms{key: keyID, context: serializedContext, hasContext: true}, nil
+}
+
+// NewSSEC returns a new server-side-encryption using SSE-C and the provided key.
+// The key must be 32 bytes long.
+func NewSSEC(key []byte) (ServerSide, error) {
+        if len(key) != 32 {
+                return nil, errors.New("encrypt: SSE-C key must be 256 bit long")
+        }
+        sse := ssec{}
+        copy(sse[:], key)
+        return sse, nil
+}
+
+// SSE transforms a SSE-C copy encryption into a SSE-C encryption.
+// It is the inverse of SSECopy(...).
+//
+// If the provided sse is no SSE-C copy encryption SSE returns
+// sse unmodified.
+func SSE(sse ServerSide) ServerSide {
+        if sse == nil || sse.Type() != SSEC {
+                return sse
+        }
+        if sse, ok := sse.(ssecCopy); ok {
+                return ssec(sse)
+        }
+        return sse
+}
+
+// SSECopy transforms a SSE-C encryption into a SSE-C copy
+// encryption. This is required for SSE-C key rotation or a SSE-C
+// copy where the source and the destination should be encrypted.
+//
+// If the provided sse is no SSE-C encryption SSECopy returns
+// sse unmodified.
+func SSECopy(sse ServerSide) ServerSide {
+        if sse == nil || sse.Type() != SSEC {
+                return sse
+        }
+        if sse, ok := sse.(ssec); ok {
+                return ssecCopy(sse)
+        }
+        return sse
+}
+
+type ssec [32]byte
+
+func (s ssec) Type() Type { return SSEC }
+
+func (s ssec) Marshal(h http.Header) {
+        keyMD5 := md5.Sum(s[:])
+        h.Set(SseCustomerAlgorithm, "AES256")
+        h.Set(SseCustomerKey, base64.StdEncoding.EncodeToString(s[:]))
+        h.Set(SseCustomerKeyMD5, base64.StdEncoding.EncodeToString(keyMD5[:]))
+}
+
+type ssecCopy [32]byte
+
+func (s ssecCopy) Type() Type { return SSEC }
+
+func (s ssecCopy) Marshal(h http.Header) {
+        keyMD5 := md5.Sum(s[:])
+        h.Set(SseCopyCustomerAlgorithm, "AES256")
+        h.Set(SseCopyCustomerKey, base64.StdEncoding.EncodeToString(s[:]))
+        h.Set(SseCopyCustomerKeyMD5, base64.StdEncoding.EncodeToString(keyMD5[:]))
+}
+
+type s3 struct{}
+
+func (s s3) Type() Type { return S3 }
+
+func (s s3) Marshal(h http.Header) { h.Set(SseGenericHeader, "AES256") }
+
+type kms struct {
+        key        string
+        context    []byte
+        hasContext bool
+}
+
+func (s kms) Type() Type { return KMS }
+
+func (s kms) Marshal(h http.Header) {
+        h.Set(SseGenericHeader, "aws:kms")
+        if s.key != "" {
+                h.Set(SseKmsKeyID, s.key)
+        }
+        if s.hasContext {
+                h.Set(SseEncryptionContext, base64.StdEncoding.EncodeToString(s.context))
+        }
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/lifecycle/lifecycle.go b/vendor/github.com/minio/minio-go/v7/pkg/lifecycle/lifecycle.go
new file mode 100644
index 0000000..c52f78c
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/lifecycle/lifecycle.go
@@ -0,0 +1,491 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2020 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 lifecycle contains all the lifecycle related data types and marshallers.
+package lifecycle
+
+import (
+        "encoding/json"
+        "encoding/xml"
+        "errors"
+        "time"
+)
+
+var errMissingStorageClass = errors.New("storage-class cannot be empty")
+
+// AbortIncompleteMultipartUpload structure, not supported yet on MinIO
+type AbortIncompleteMultipartUpload struct {
+        XMLName             xml.Name       `xml:"AbortIncompleteMultipartUpload,omitempty"  json:"-"`
+        DaysAfterInitiation ExpirationDays `xml:"DaysAfterInitiation,omitempty" json:"DaysAfterInitiation,omitempty"`
+}
+
+// IsDaysNull returns true if days field is null
+func (n AbortIncompleteMultipartUpload) IsDaysNull() bool {
+        return n.DaysAfterInitiation == ExpirationDays(0)
+}
+
+// MarshalXML if days after initiation is set to non-zero value
+func (n AbortIncompleteMultipartUpload) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+        if n.IsDaysNull() {
+                return nil
+        }
+        type abortIncompleteMultipartUploadWrapper AbortIncompleteMultipartUpload
+        return e.EncodeElement(abortIncompleteMultipartUploadWrapper(n), start)
+}
+
+// NoncurrentVersionExpiration - Specifies when noncurrent object versions expire.
+// Upon expiration, server permanently deletes the noncurrent object versions.
+// Set this lifecycle configuration action on a bucket that has versioning enabled
+// (or suspended) to request server delete noncurrent object versions at a
+// specific period in the object's lifetime.
+type NoncurrentVersionExpiration struct {
+        XMLName                 xml.Name       `xml:"NoncurrentVersionExpiration" json:"-"`
+        NoncurrentDays          ExpirationDays `xml:"NoncurrentDays,omitempty" json:"NoncurrentDays,omitempty"`
+        NewerNoncurrentVersions int            `xml:"NewerNoncurrentVersions,omitempty" json:"NewerNoncurrentVersions,omitempty"`
+}
+
+// MarshalXML if n is non-empty, i.e has a non-zero NoncurrentDays or NewerNoncurrentVersions.
+func (n NoncurrentVersionExpiration) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+        if n.isNull() {
+                return nil
+        }
+        type noncurrentVersionExpirationWrapper NoncurrentVersionExpiration
+        return e.EncodeElement(noncurrentVersionExpirationWrapper(n), start)
+}
+
+// IsDaysNull returns true if days field is null
+func (n NoncurrentVersionExpiration) IsDaysNull() bool {
+        return n.NoncurrentDays == ExpirationDays(0)
+}
+
+func (n NoncurrentVersionExpiration) isNull() bool {
+        return n.IsDaysNull() && n.NewerNoncurrentVersions == 0
+}
+
+// NoncurrentVersionTransition structure, set this action to request server to
+// transition noncurrent object versions to different set storage classes
+// at a specific period in the object's lifetime.
+type NoncurrentVersionTransition struct {
+        XMLName                 xml.Name       `xml:"NoncurrentVersionTransition,omitempty"  json:"-"`
+        StorageClass            string         `xml:"StorageClass,omitempty" json:"StorageClass,omitempty"`
+        NoncurrentDays          ExpirationDays `xml:"NoncurrentDays" json:"NoncurrentDays"`
+        NewerNoncurrentVersions int            `xml:"NewerNoncurrentVersions,omitempty" json:"NewerNoncurrentVersions,omitempty"`
+}
+
+// IsDaysNull returns true if days field is null
+func (n NoncurrentVersionTransition) IsDaysNull() bool {
+        return n.NoncurrentDays == ExpirationDays(0)
+}
+
+// IsStorageClassEmpty returns true if storage class field is empty
+func (n NoncurrentVersionTransition) IsStorageClassEmpty() bool {
+        return n.StorageClass == ""
+}
+
+func (n NoncurrentVersionTransition) isNull() bool {
+        return n.StorageClass == ""
+}
+
+// UnmarshalJSON implements NoncurrentVersionTransition JSONify
+func (n *NoncurrentVersionTransition) UnmarshalJSON(b []byte) error {
+        type noncurrentVersionTransition NoncurrentVersionTransition
+        var nt noncurrentVersionTransition
+        err := json.Unmarshal(b, &nt)
+        if err != nil {
+                return err
+        }
+
+        if nt.StorageClass == "" {
+                return errMissingStorageClass
+        }
+        *n = NoncurrentVersionTransition(nt)
+        return nil
+}
+
+// MarshalXML is extended to leave out
+// <NoncurrentVersionTransition></NoncurrentVersionTransition> tags
+func (n NoncurrentVersionTransition) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+        if n.isNull() {
+                return nil
+        }
+        type noncurrentVersionTransitionWrapper NoncurrentVersionTransition
+        return e.EncodeElement(noncurrentVersionTransitionWrapper(n), start)
+}
+
+// Tag structure key/value pair representing an object tag to apply lifecycle configuration
+type Tag struct {
+        XMLName xml.Name `xml:"Tag,omitempty" json:"-"`
+        Key     string   `xml:"Key,omitempty" json:"Key,omitempty"`
+        Value   string   `xml:"Value,omitempty" json:"Value,omitempty"`
+}
+
+// IsEmpty returns whether this tag is empty or not.
+func (tag Tag) IsEmpty() bool {
+        return tag.Key == ""
+}
+
+// Transition structure - transition details of lifecycle configuration
+type Transition struct {
+        XMLName      xml.Name       `xml:"Transition" json:"-"`
+        Date         ExpirationDate `xml:"Date,omitempty" json:"Date,omitempty"`
+        StorageClass string         `xml:"StorageClass,omitempty" json:"StorageClass,omitempty"`
+        Days         ExpirationDays `xml:"Days" json:"Days"`
+}
+
+// UnmarshalJSON returns an error if storage-class is empty.
+func (t *Transition) UnmarshalJSON(b []byte) error {
+        type transition Transition
+        var tr transition
+        err := json.Unmarshal(b, &tr)
+        if err != nil {
+                return err
+        }
+
+        if tr.StorageClass == "" {
+                return errMissingStorageClass
+        }
+        *t = Transition(tr)
+        return nil
+}
+
+// MarshalJSON customizes json encoding by omitting empty values
+func (t Transition) MarshalJSON() ([]byte, error) {
+        if t.IsNull() {
+                return nil, nil
+        }
+        type transition struct {
+                Date         *ExpirationDate `json:"Date,omitempty"`
+                StorageClass string          `json:"StorageClass,omitempty"`
+                Days         *ExpirationDays `json:"Days"`
+        }
+
+        newt := transition{
+                StorageClass: t.StorageClass,
+        }
+
+        if !t.IsDateNull() {
+                newt.Date = &t.Date
+        } else {
+                newt.Days = &t.Days
+        }
+        return json.Marshal(newt)
+}
+
+// IsDaysNull returns true if days field is null
+func (t Transition) IsDaysNull() bool {
+        return t.Days == ExpirationDays(0)
+}
+
+// IsDateNull returns true if date field is null
+func (t Transition) IsDateNull() bool {
+        return t.Date.Time.IsZero()
+}
+
+// IsNull returns true if no storage-class is set.
+func (t Transition) IsNull() bool {
+        return t.StorageClass == ""
+}
+
+// MarshalXML is transition is non null
+func (t Transition) MarshalXML(en *xml.Encoder, startElement xml.StartElement) error {
+        if t.IsNull() {
+                return nil
+        }
+        type transitionWrapper Transition
+        return en.EncodeElement(transitionWrapper(t), startElement)
+}
+
+// And And Rule for LifecycleTag, to be used in LifecycleRuleFilter
+type And struct {
+        XMLName               xml.Name `xml:"And" json:"-"`
+        Prefix                string   `xml:"Prefix" json:"Prefix,omitempty"`
+        Tags                  []Tag    `xml:"Tag" json:"Tags,omitempty"`
+        ObjectSizeLessThan    int64    `xml:"ObjectSizeLessThan,omitempty" json:"ObjectSizeLessThan,omitempty"`
+        ObjectSizeGreaterThan int64    `xml:"ObjectSizeGreaterThan,omitempty" json:"ObjectSizeGreaterThan,omitempty"`
+}
+
+// IsEmpty returns true if Tags field is null
+func (a And) IsEmpty() bool {
+        return len(a.Tags) == 0 && a.Prefix == "" &&
+                a.ObjectSizeLessThan == 0 && a.ObjectSizeGreaterThan == 0
+}
+
+// Filter will be used in selecting rule(s) for lifecycle configuration
+type Filter struct {
+        XMLName               xml.Name `xml:"Filter" json:"-"`
+        And                   And      `xml:"And,omitempty" json:"And,omitempty"`
+        Prefix                string   `xml:"Prefix,omitempty" json:"Prefix,omitempty"`
+        Tag                   Tag      `xml:"Tag,omitempty" json:"Tag,omitempty"`
+        ObjectSizeLessThan    int64    `xml:"ObjectSizeLessThan,omitempty" json:"ObjectSizeLessThan,omitempty"`
+        ObjectSizeGreaterThan int64    `xml:"ObjectSizeGreaterThan,omitempty" json:"ObjectSizeGreaterThan,omitempty"`
+}
+
+// IsNull returns true if all Filter fields are empty.
+func (f Filter) IsNull() bool {
+        return f.Tag.IsEmpty() && f.And.IsEmpty() && f.Prefix == "" &&
+                f.ObjectSizeLessThan == 0 && f.ObjectSizeGreaterThan == 0
+}
+
+// MarshalJSON customizes json encoding by removing empty values.
+func (f Filter) MarshalJSON() ([]byte, error) {
+        type filter struct {
+                And                   *And   `json:"And,omitempty"`
+                Prefix                string `json:"Prefix,omitempty"`
+                Tag                   *Tag   `json:"Tag,omitempty"`
+                ObjectSizeLessThan    int64  `json:"ObjectSizeLessThan,omitempty"`
+                ObjectSizeGreaterThan int64  `json:"ObjectSizeGreaterThan,omitempty"`
+        }
+
+        newf := filter{
+                Prefix: f.Prefix,
+        }
+        if !f.Tag.IsEmpty() {
+                newf.Tag = &f.Tag
+        }
+        if !f.And.IsEmpty() {
+                newf.And = &f.And
+        }
+        newf.ObjectSizeLessThan = f.ObjectSizeLessThan
+        newf.ObjectSizeGreaterThan = f.ObjectSizeGreaterThan
+        return json.Marshal(newf)
+}
+
+// MarshalXML - produces the xml representation of the Filter struct
+// only one of Prefix, And and Tag should be present in the output.
+func (f Filter) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+        if err := e.EncodeToken(start); err != nil {
+                return err
+        }
+
+        switch {
+        case !f.And.IsEmpty():
+                if err := e.EncodeElement(f.And, xml.StartElement{Name: xml.Name{Local: "And"}}); err != nil {
+                        return err
+                }
+        case !f.Tag.IsEmpty():
+                if err := e.EncodeElement(f.Tag, xml.StartElement{Name: xml.Name{Local: "Tag"}}); err != nil {
+                        return err
+                }
+        default:
+                if f.ObjectSizeLessThan > 0 {
+                        if err := e.EncodeElement(f.ObjectSizeLessThan, xml.StartElement{Name: xml.Name{Local: "ObjectSizeLessThan"}}); err != nil {
+                                return err
+                        }
+                        break
+                }
+                if f.ObjectSizeGreaterThan > 0 {
+                        if err := e.EncodeElement(f.ObjectSizeGreaterThan, xml.StartElement{Name: xml.Name{Local: "ObjectSizeGreaterThan"}}); err != nil {
+                                return err
+                        }
+                        break
+                }
+                // Print empty Prefix field only when everything else is empty
+                if err := e.EncodeElement(f.Prefix, xml.StartElement{Name: xml.Name{Local: "Prefix"}}); err != nil {
+                        return err
+                }
+        }
+
+        return e.EncodeToken(xml.EndElement{Name: start.Name})
+}
+
+// ExpirationDays is a type alias to unmarshal Days in Expiration
+type ExpirationDays int
+
+// MarshalXML encodes number of days to expire if it is non-zero and
+// encodes empty string otherwise
+func (eDays ExpirationDays) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {
+        if eDays == 0 {
+                return nil
+        }
+        return e.EncodeElement(int(eDays), startElement)
+}
+
+// ExpirationDate is a embedded type containing time.Time to unmarshal
+// Date in Expiration
+type ExpirationDate struct {
+        time.Time
+}
+
+// MarshalXML encodes expiration date if it is non-zero and encodes
+// empty string otherwise
+func (eDate ExpirationDate) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {
+        if eDate.Time.IsZero() {
+                return nil
+        }
+        return e.EncodeElement(eDate.Format(time.RFC3339), startElement)
+}
+
+// ExpireDeleteMarker represents value of ExpiredObjectDeleteMarker field in Expiration XML element.
+type ExpireDeleteMarker ExpirationBoolean
+
+// IsEnabled returns true if the auto delete-marker expiration is enabled
+func (e ExpireDeleteMarker) IsEnabled() bool {
+        return bool(e)
+}
+
+// ExpirationBoolean represents an XML version of 'bool' type
+type ExpirationBoolean bool
+
+// MarshalXML encodes delete marker boolean into an XML form.
+func (b ExpirationBoolean) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {
+        if !b {
+                return nil
+        }
+        type booleanWrapper ExpirationBoolean
+        return e.EncodeElement(booleanWrapper(b), startElement)
+}
+
+// IsEnabled returns true if the expiration boolean is enabled
+func (b ExpirationBoolean) IsEnabled() bool {
+        return bool(b)
+}
+
+// Expiration structure - expiration details of lifecycle configuration
+type Expiration struct {
+        XMLName      xml.Name           `xml:"Expiration,omitempty" json:"-"`
+        Date         ExpirationDate     `xml:"Date,omitempty" json:"Date,omitempty"`
+        Days         ExpirationDays     `xml:"Days,omitempty" json:"Days,omitempty"`
+        DeleteMarker ExpireDeleteMarker `xml:"ExpiredObjectDeleteMarker,omitempty" json:"ExpiredObjectDeleteMarker,omitempty"`
+        DeleteAll    ExpirationBoolean  `xml:"ExpiredObjectAllVersions,omitempty" json:"ExpiredObjectAllVersions,omitempty"`
+}
+
+// MarshalJSON customizes json encoding by removing empty day/date specification.
+func (e Expiration) MarshalJSON() ([]byte, error) {
+        type expiration struct {
+                Date         *ExpirationDate    `json:"Date,omitempty"`
+                Days         *ExpirationDays    `json:"Days,omitempty"`
+                DeleteMarker ExpireDeleteMarker `json:"ExpiredObjectDeleteMarker,omitempty"`
+                DeleteAll    ExpirationBoolean  `json:"ExpiredObjectAllVersions,omitempty"`
+        }
+
+        newexp := expiration{
+                DeleteMarker: e.DeleteMarker,
+                DeleteAll:    e.DeleteAll,
+        }
+        if !e.IsDaysNull() {
+                newexp.Days = &e.Days
+        }
+        if !e.IsDateNull() {
+                newexp.Date = &e.Date
+        }
+        return json.Marshal(newexp)
+}
+
+// IsDaysNull returns true if days field is null
+func (e Expiration) IsDaysNull() bool {
+        return e.Days == ExpirationDays(0)
+}
+
+// IsDateNull returns true if date field is null
+func (e Expiration) IsDateNull() bool {
+        return e.Date.Time.IsZero()
+}
+
+// IsDeleteMarkerExpirationEnabled returns true if the auto-expiration of delete marker is enabled
+func (e Expiration) IsDeleteMarkerExpirationEnabled() bool {
+        return e.DeleteMarker.IsEnabled()
+}
+
+// IsNull returns true if both date and days fields are null
+func (e Expiration) IsNull() bool {
+        return e.IsDaysNull() && e.IsDateNull() && !e.IsDeleteMarkerExpirationEnabled()
+}
+
+// MarshalXML is expiration is non null
+func (e Expiration) MarshalXML(en *xml.Encoder, startElement xml.StartElement) error {
+        if e.IsNull() {
+                return nil
+        }
+        type expirationWrapper Expiration
+        return en.EncodeElement(expirationWrapper(e), startElement)
+}
+
+// MarshalJSON customizes json encoding by omitting empty values
+func (r Rule) MarshalJSON() ([]byte, error) {
+        type rule struct {
+                AbortIncompleteMultipartUpload *AbortIncompleteMultipartUpload `json:"AbortIncompleteMultipartUpload,omitempty"`
+                Expiration                     *Expiration                     `json:"Expiration,omitempty"`
+                ID                             string                          `json:"ID"`
+                RuleFilter                     *Filter                         `json:"Filter,omitempty"`
+                NoncurrentVersionExpiration    *NoncurrentVersionExpiration    `json:"NoncurrentVersionExpiration,omitempty"`
+                NoncurrentVersionTransition    *NoncurrentVersionTransition    `json:"NoncurrentVersionTransition,omitempty"`
+                Prefix                         string                          `json:"Prefix,omitempty"`
+                Status                         string                          `json:"Status"`
+                Transition                     *Transition                     `json:"Transition,omitempty"`
+        }
+        newr := rule{
+                Prefix: r.Prefix,
+                Status: r.Status,
+                ID:     r.ID,
+        }
+
+        if !r.RuleFilter.IsNull() {
+                newr.RuleFilter = &r.RuleFilter
+        }
+        if !r.AbortIncompleteMultipartUpload.IsDaysNull() {
+                newr.AbortIncompleteMultipartUpload = &r.AbortIncompleteMultipartUpload
+        }
+        if !r.Expiration.IsNull() {
+                newr.Expiration = &r.Expiration
+        }
+        if !r.Transition.IsNull() {
+                newr.Transition = &r.Transition
+        }
+        if !r.NoncurrentVersionExpiration.isNull() {
+                newr.NoncurrentVersionExpiration = &r.NoncurrentVersionExpiration
+        }
+        if !r.NoncurrentVersionTransition.isNull() {
+                newr.NoncurrentVersionTransition = &r.NoncurrentVersionTransition
+        }
+
+        return json.Marshal(newr)
+}
+
+// Rule represents a single rule in lifecycle configuration
+type Rule struct {
+        XMLName                        xml.Name                       `xml:"Rule,omitempty" json:"-"`
+        AbortIncompleteMultipartUpload AbortIncompleteMultipartUpload `xml:"AbortIncompleteMultipartUpload,omitempty" json:"AbortIncompleteMultipartUpload,omitempty"`
+        Expiration                     Expiration                     `xml:"Expiration,omitempty" json:"Expiration,omitempty"`
+        ID                             string                         `xml:"ID" json:"ID"`
+        RuleFilter                     Filter                         `xml:"Filter,omitempty" json:"Filter,omitempty"`
+        NoncurrentVersionExpiration    NoncurrentVersionExpiration    `xml:"NoncurrentVersionExpiration,omitempty"  json:"NoncurrentVersionExpiration,omitempty"`
+        NoncurrentVersionTransition    NoncurrentVersionTransition    `xml:"NoncurrentVersionTransition,omitempty" json:"NoncurrentVersionTransition,omitempty"`
+        Prefix                         string                         `xml:"Prefix,omitempty" json:"Prefix,omitempty"`
+        Status                         string                         `xml:"Status" json:"Status"`
+        Transition                     Transition                     `xml:"Transition,omitempty" json:"Transition,omitempty"`
+}
+
+// Configuration is a collection of Rule objects.
+type Configuration struct {
+        XMLName xml.Name `xml:"LifecycleConfiguration,omitempty" json:"-"`
+        Rules   []Rule   `xml:"Rule"`
+}
+
+// Empty check if lifecycle configuration is empty
+func (c *Configuration) Empty() bool {
+        if c == nil {
+                return true
+        }
+        return len(c.Rules) == 0
+}
+
+// NewConfiguration initializes a fresh lifecycle configuration
+// for manipulation, such as setting and removing lifecycle rules
+// and filters.
+func NewConfiguration() *Configuration {
+        return &Configuration{}
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/notification/info.go b/vendor/github.com/minio/minio-go/v7/pkg/notification/info.go
new file mode 100644
index 0000000..126661a
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/notification/info.go
@@ -0,0 +1,78 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2017-2020 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 notification
+
+// Indentity represents the user id, this is a compliance field.
+type identity struct {
+        PrincipalID string `json:"principalId"`
+}
+
+// event bucket metadata.
+type bucketMeta struct {
+        Name          string   `json:"name"`
+        OwnerIdentity identity `json:"ownerIdentity"`
+        ARN           string   `json:"arn"`
+}
+
+// event object metadata.
+type objectMeta struct {
+        Key          string            `json:"key"`
+        Size         int64             `json:"size,omitempty"`
+        ETag         string            `json:"eTag,omitempty"`
+        ContentType  string            `json:"contentType,omitempty"`
+        UserMetadata map[string]string `json:"userMetadata,omitempty"`
+        VersionID    string            `json:"versionId,omitempty"`
+        Sequencer    string            `json:"sequencer"`
+}
+
+// event server specific metadata.
+type eventMeta struct {
+        SchemaVersion   string     `json:"s3SchemaVersion"`
+        ConfigurationID string     `json:"configurationId"`
+        Bucket          bucketMeta `json:"bucket"`
+        Object          objectMeta `json:"object"`
+}
+
+// sourceInfo represents information on the client that
+// triggered the event notification.
+type sourceInfo struct {
+        Host      string `json:"host"`
+        Port      string `json:"port"`
+        UserAgent string `json:"userAgent"`
+}
+
+// Event represents an Amazon an S3 bucket notification event.
+type Event struct {
+        EventVersion      string            `json:"eventVersion"`
+        EventSource       string            `json:"eventSource"`
+        AwsRegion         string            `json:"awsRegion"`
+        EventTime         string            `json:"eventTime"`
+        EventName         string            `json:"eventName"`
+        UserIdentity      identity          `json:"userIdentity"`
+        RequestParameters map[string]string `json:"requestParameters"`
+        ResponseElements  map[string]string `json:"responseElements"`
+        S3                eventMeta         `json:"s3"`
+        Source            sourceInfo        `json:"source"`
+}
+
+// Info - represents the collection of notification events, additionally
+// also reports errors if any while listening on bucket notifications.
+type Info struct {
+        Records []Event
+        Err     error
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/notification/notification.go b/vendor/github.com/minio/minio-go/v7/pkg/notification/notification.go
new file mode 100644
index 0000000..a44799d
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/notification/notification.go
@@ -0,0 +1,440 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2020 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 notification
+
+import (
+        "encoding/xml"
+        "errors"
+        "fmt"
+        "strings"
+
+        "github.com/minio/minio-go/v7/pkg/set"
+)
+
+// EventType is a S3 notification event associated to the bucket notification configuration
+type EventType string
+
+// The role of all event types are described in :
+//
+//      http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html#notification-how-to-event-types-and-destinations
+const (
+        ObjectCreatedAll                                   EventType = "s3:ObjectCreated:*"
+        ObjectCreatedPut                                   EventType = "s3:ObjectCreated:Put"
+        ObjectCreatedPost                                  EventType = "s3:ObjectCreated:Post"
+        ObjectCreatedCopy                                  EventType = "s3:ObjectCreated:Copy"
+        ObjectCreatedDeleteTagging                         EventType = "s3:ObjectCreated:DeleteTagging"
+        ObjectCreatedCompleteMultipartUpload               EventType = "s3:ObjectCreated:CompleteMultipartUpload"
+        ObjectCreatedPutLegalHold                          EventType = "s3:ObjectCreated:PutLegalHold"
+        ObjectCreatedPutRetention                          EventType = "s3:ObjectCreated:PutRetention"
+        ObjectCreatedPutTagging                            EventType = "s3:ObjectCreated:PutTagging"
+        ObjectAccessedGet                                  EventType = "s3:ObjectAccessed:Get"
+        ObjectAccessedHead                                 EventType = "s3:ObjectAccessed:Head"
+        ObjectAccessedGetRetention                         EventType = "s3:ObjectAccessed:GetRetention"
+        ObjectAccessedGetLegalHold                         EventType = "s3:ObjectAccessed:GetLegalHold"
+        ObjectAccessedAll                                  EventType = "s3:ObjectAccessed:*"
+        ObjectRemovedAll                                   EventType = "s3:ObjectRemoved:*"
+        ObjectRemovedDelete                                EventType = "s3:ObjectRemoved:Delete"
+        ObjectRemovedDeleteMarkerCreated                   EventType = "s3:ObjectRemoved:DeleteMarkerCreated"
+        ObjectReducedRedundancyLostObject                  EventType = "s3:ReducedRedundancyLostObject"
+        ObjectTransitionAll                                EventType = "s3:ObjectTransition:*"
+        ObjectTransitionFailed                             EventType = "s3:ObjectTransition:Failed"
+        ObjectTransitionComplete                           EventType = "s3:ObjectTransition:Complete"
+        ObjectTransitionPost                               EventType = "s3:ObjectRestore:Post"
+        ObjectTransitionCompleted                          EventType = "s3:ObjectRestore:Completed"
+        ObjectReplicationAll                               EventType = "s3:Replication:*"
+        ObjectReplicationOperationCompletedReplication     EventType = "s3:Replication:OperationCompletedReplication"
+        ObjectReplicationOperationFailedReplication        EventType = "s3:Replication:OperationFailedReplication"
+        ObjectReplicationOperationMissedThreshold          EventType = "s3:Replication:OperationMissedThreshold"
+        ObjectReplicationOperationNotTracked               EventType = "s3:Replication:OperationNotTracked"
+        ObjectReplicationOperationReplicatedAfterThreshold EventType = "s3:Replication:OperationReplicatedAfterThreshold"
+        ObjectScannerManyVersions                          EventType = "s3:Scanner:ManyVersions"
+        ObjectScannerBigPrefix                             EventType = "s3:Scanner:BigPrefix"
+        ObjectScannerAll                                   EventType = "s3:Scanner:*"
+        BucketCreatedAll                                   EventType = "s3:BucketCreated:*"
+        BucketRemovedAll                                   EventType = "s3:BucketRemoved:*"
+)
+
+// FilterRule - child of S3Key, a tag in the notification xml which
+// carries suffix/prefix filters
+type FilterRule struct {
+        Name  string `xml:"Name"`
+        Value string `xml:"Value"`
+}
+
+// S3Key - child of Filter, a tag in the notification xml which
+// carries suffix/prefix filters
+type S3Key struct {
+        FilterRules []FilterRule `xml:"FilterRule,omitempty"`
+}
+
+// Filter - a tag in the notification xml structure which carries
+// suffix/prefix filters
+type Filter struct {
+        S3Key S3Key `xml:"S3Key,omitempty"`
+}
+
+// Arn - holds ARN information that will be sent to the web service,
+// ARN desciption can be found in http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html
+type Arn struct {
+        Partition string
+        Service   string
+        Region    string
+        AccountID string
+        Resource  string
+}
+
+// NewArn creates new ARN based on the given partition, service, region, account id and resource
+func NewArn(partition, service, region, accountID, resource string) Arn {
+        return Arn{
+                Partition: partition,
+                Service:   service,
+                Region:    region,
+                AccountID: accountID,
+                Resource:  resource,
+        }
+}
+
+var (
+        // ErrInvalidArnPrefix is returned when ARN string format does not start with 'arn'
+        ErrInvalidArnPrefix = errors.New("invalid ARN format, must start with 'arn:'")
+        // ErrInvalidArnFormat is returned when ARN string format is not valid
+        ErrInvalidArnFormat = errors.New("invalid ARN format, must be 'arn:<partition>:<service>:<region>:<accountID>:<resource>'")
+)
+
+// NewArnFromString parses string representation of ARN into Arn object.
+// Returns an error if the string format is incorrect.
+func NewArnFromString(arn string) (Arn, error) {
+        parts := strings.Split(arn, ":")
+        if len(parts) != 6 {
+                return Arn{}, ErrInvalidArnFormat
+        }
+        if parts[0] != "arn" {
+                return Arn{}, ErrInvalidArnPrefix
+        }
+
+        return NewArn(parts[1], parts[2], parts[3], parts[4], parts[5]), nil
+}
+
+// String returns the string format of the ARN
+func (arn Arn) String() string {
+        return "arn:" + arn.Partition + ":" + arn.Service + ":" + arn.Region + ":" + arn.AccountID + ":" + arn.Resource
+}
+
+// Config - represents one single notification configuration
+// such as topic, queue or lambda configuration.
+type Config struct {
+        ID     string      `xml:"Id,omitempty"`
+        Arn    Arn         `xml:"-"`
+        Events []EventType `xml:"Event"`
+        Filter *Filter     `xml:"Filter,omitempty"`
+}
+
+// NewConfig creates one notification config and sets the given ARN
+func NewConfig(arn Arn) Config {
+        return Config{Arn: arn, Filter: &Filter{}}
+}
+
+// AddEvents adds one event to the current notification config
+func (t *Config) AddEvents(events ...EventType) {
+        t.Events = append(t.Events, events...)
+}
+
+// AddFilterSuffix sets the suffix configuration to the current notification config
+func (t *Config) AddFilterSuffix(suffix string) {
+        if t.Filter == nil {
+                t.Filter = &Filter{}
+        }
+        newFilterRule := FilterRule{Name: "suffix", Value: suffix}
+        // Replace any suffix rule if existing and add to the list otherwise
+        for index := range t.Filter.S3Key.FilterRules {
+                if t.Filter.S3Key.FilterRules[index].Name == "suffix" {
+                        t.Filter.S3Key.FilterRules[index] = newFilterRule
+                        return
+                }
+        }
+        t.Filter.S3Key.FilterRules = append(t.Filter.S3Key.FilterRules, newFilterRule)
+}
+
+// AddFilterPrefix sets the prefix configuration to the current notification config
+func (t *Config) AddFilterPrefix(prefix string) {
+        if t.Filter == nil {
+                t.Filter = &Filter{}
+        }
+        newFilterRule := FilterRule{Name: "prefix", Value: prefix}
+        // Replace any prefix rule if existing and add to the list otherwise
+        for index := range t.Filter.S3Key.FilterRules {
+                if t.Filter.S3Key.FilterRules[index].Name == "prefix" {
+                        t.Filter.S3Key.FilterRules[index] = newFilterRule
+                        return
+                }
+        }
+        t.Filter.S3Key.FilterRules = append(t.Filter.S3Key.FilterRules, newFilterRule)
+}
+
+// EqualEventTypeList tells whether a and b contain the same events
+func EqualEventTypeList(a, b []EventType) bool {
+        if len(a) != len(b) {
+                return false
+        }
+        setA := set.NewStringSet()
+        for _, i := range a {
+                setA.Add(string(i))
+        }
+
+        setB := set.NewStringSet()
+        for _, i := range b {
+                setB.Add(string(i))
+        }
+
+        return setA.Difference(setB).IsEmpty()
+}
+
+// EqualFilterRuleList tells whether a and b contain the same filters
+func EqualFilterRuleList(a, b []FilterRule) bool {
+        if len(a) != len(b) {
+                return false
+        }
+
+        setA := set.NewStringSet()
+        for _, i := range a {
+                setA.Add(fmt.Sprintf("%s-%s", i.Name, i.Value))
+        }
+
+        setB := set.NewStringSet()
+        for _, i := range b {
+                setB.Add(fmt.Sprintf("%s-%s", i.Name, i.Value))
+        }
+
+        return setA.Difference(setB).IsEmpty()
+}
+
+// Equal returns whether this `Config` is equal to another defined by the passed parameters
+func (t *Config) Equal(events []EventType, prefix, suffix string) bool {
+        if t == nil {
+                return false
+        }
+
+        // Compare events
+        passEvents := EqualEventTypeList(t.Events, events)
+
+        // Compare filters
+        var newFilterRules []FilterRule
+        if prefix != "" {
+                newFilterRules = append(newFilterRules, FilterRule{Name: "prefix", Value: prefix})
+        }
+        if suffix != "" {
+                newFilterRules = append(newFilterRules, FilterRule{Name: "suffix", Value: suffix})
+        }
+
+        var currentFilterRules []FilterRule
+        if t.Filter != nil {
+                currentFilterRules = t.Filter.S3Key.FilterRules
+        }
+
+        passFilters := EqualFilterRuleList(currentFilterRules, newFilterRules)
+        return passEvents && passFilters
+}
+
+// TopicConfig carries one single topic notification configuration
+type TopicConfig struct {
+        Config
+        Topic string `xml:"Topic"`
+}
+
+// QueueConfig carries one single queue notification configuration
+type QueueConfig struct {
+        Config
+        Queue string `xml:"Queue"`
+}
+
+// LambdaConfig carries one single cloudfunction notification configuration
+type LambdaConfig struct {
+        Config
+        Lambda string `xml:"CloudFunction"`
+}
+
+// Configuration - the struct that represents the whole XML to be sent to the web service
+type Configuration struct {
+        XMLName       xml.Name       `xml:"NotificationConfiguration"`
+        LambdaConfigs []LambdaConfig `xml:"CloudFunctionConfiguration"`
+        TopicConfigs  []TopicConfig  `xml:"TopicConfiguration"`
+        QueueConfigs  []QueueConfig  `xml:"QueueConfiguration"`
+}
+
+// AddTopic adds a given topic config to the general bucket notification config
+func (b *Configuration) AddTopic(topicConfig Config) bool {
+        newTopicConfig := TopicConfig{Config: topicConfig, Topic: topicConfig.Arn.String()}
+        for _, n := range b.TopicConfigs {
+                // If new config matches existing one
+                if n.Topic == newTopicConfig.Arn.String() && newTopicConfig.Filter == n.Filter {
+
+                        existingConfig := set.NewStringSet()
+                        for _, v := range n.Events {
+                                existingConfig.Add(string(v))
+                        }
+
+                        newConfig := set.NewStringSet()
+                        for _, v := range topicConfig.Events {
+                                newConfig.Add(string(v))
+                        }
+
+                        if !newConfig.Intersection(existingConfig).IsEmpty() {
+                                return false
+                        }
+                }
+        }
+        b.TopicConfigs = append(b.TopicConfigs, newTopicConfig)
+        return true
+}
+
+// AddQueue adds a given queue config to the general bucket notification config
+func (b *Configuration) AddQueue(queueConfig Config) bool {
+        newQueueConfig := QueueConfig{Config: queueConfig, Queue: queueConfig.Arn.String()}
+        for _, n := range b.QueueConfigs {
+                if n.Queue == newQueueConfig.Arn.String() && newQueueConfig.Filter == n.Filter {
+
+                        existingConfig := set.NewStringSet()
+                        for _, v := range n.Events {
+                                existingConfig.Add(string(v))
+                        }
+
+                        newConfig := set.NewStringSet()
+                        for _, v := range queueConfig.Events {
+                                newConfig.Add(string(v))
+                        }
+
+                        if !newConfig.Intersection(existingConfig).IsEmpty() {
+                                return false
+                        }
+                }
+        }
+        b.QueueConfigs = append(b.QueueConfigs, newQueueConfig)
+        return true
+}
+
+// AddLambda adds a given lambda config to the general bucket notification config
+func (b *Configuration) AddLambda(lambdaConfig Config) bool {
+        newLambdaConfig := LambdaConfig{Config: lambdaConfig, Lambda: lambdaConfig.Arn.String()}
+        for _, n := range b.LambdaConfigs {
+                if n.Lambda == newLambdaConfig.Arn.String() && newLambdaConfig.Filter == n.Filter {
+
+                        existingConfig := set.NewStringSet()
+                        for _, v := range n.Events {
+                                existingConfig.Add(string(v))
+                        }
+
+                        newConfig := set.NewStringSet()
+                        for _, v := range lambdaConfig.Events {
+                                newConfig.Add(string(v))
+                        }
+
+                        if !newConfig.Intersection(existingConfig).IsEmpty() {
+                                return false
+                        }
+                }
+        }
+        b.LambdaConfigs = append(b.LambdaConfigs, newLambdaConfig)
+        return true
+}
+
+// RemoveTopicByArn removes all topic configurations that match the exact specified ARN
+func (b *Configuration) RemoveTopicByArn(arn Arn) {
+        var topics []TopicConfig
+        for _, topic := range b.TopicConfigs {
+                if topic.Topic != arn.String() {
+                        topics = append(topics, topic)
+                }
+        }
+        b.TopicConfigs = topics
+}
+
+// ErrNoConfigMatch is returned when a notification configuration (sqs,sns,lambda) is not found when trying to delete
+var ErrNoConfigMatch = errors.New("no notification configuration matched")
+
+// RemoveTopicByArnEventsPrefixSuffix removes a topic configuration that match the exact specified ARN, events, prefix and suffix
+func (b *Configuration) RemoveTopicByArnEventsPrefixSuffix(arn Arn, events []EventType, prefix, suffix string) error {
+        removeIndex := -1
+        for i, v := range b.TopicConfigs {
+                // if it matches events and filters, mark the index for deletion
+                if v.Topic == arn.String() && v.Config.Equal(events, prefix, suffix) {
+                        removeIndex = i
+                        break // since we have at most one matching config
+                }
+        }
+        if removeIndex >= 0 {
+                b.TopicConfigs = append(b.TopicConfigs[:removeIndex], b.TopicConfigs[removeIndex+1:]...)
+                return nil
+        }
+        return ErrNoConfigMatch
+}
+
+// RemoveQueueByArn removes all queue configurations that match the exact specified ARN
+func (b *Configuration) RemoveQueueByArn(arn Arn) {
+        var queues []QueueConfig
+        for _, queue := range b.QueueConfigs {
+                if queue.Queue != arn.String() {
+                        queues = append(queues, queue)
+                }
+        }
+        b.QueueConfigs = queues
+}
+
+// RemoveQueueByArnEventsPrefixSuffix removes a queue configuration that match the exact specified ARN, events, prefix and suffix
+func (b *Configuration) RemoveQueueByArnEventsPrefixSuffix(arn Arn, events []EventType, prefix, suffix string) error {
+        removeIndex := -1
+        for i, v := range b.QueueConfigs {
+                // if it matches events and filters, mark the index for deletion
+                if v.Queue == arn.String() && v.Config.Equal(events, prefix, suffix) {
+                        removeIndex = i
+                        break // since we have at most one matching config
+                }
+        }
+        if removeIndex >= 0 {
+                b.QueueConfigs = append(b.QueueConfigs[:removeIndex], b.QueueConfigs[removeIndex+1:]...)
+                return nil
+        }
+        return ErrNoConfigMatch
+}
+
+// RemoveLambdaByArn removes all lambda configurations that match the exact specified ARN
+func (b *Configuration) RemoveLambdaByArn(arn Arn) {
+        var lambdas []LambdaConfig
+        for _, lambda := range b.LambdaConfigs {
+                if lambda.Lambda != arn.String() {
+                        lambdas = append(lambdas, lambda)
+                }
+        }
+        b.LambdaConfigs = lambdas
+}
+
+// RemoveLambdaByArnEventsPrefixSuffix removes a topic configuration that match the exact specified ARN, events, prefix and suffix
+func (b *Configuration) RemoveLambdaByArnEventsPrefixSuffix(arn Arn, events []EventType, prefix, suffix string) error {
+        removeIndex := -1
+        for i, v := range b.LambdaConfigs {
+                // if it matches events and filters, mark the index for deletion
+                if v.Lambda == arn.String() && v.Config.Equal(events, prefix, suffix) {
+                        removeIndex = i
+                        break // since we have at most one matching config
+                }
+        }
+        if removeIndex >= 0 {
+                b.LambdaConfigs = append(b.LambdaConfigs[:removeIndex], b.LambdaConfigs[removeIndex+1:]...)
+                return nil
+        }
+        return ErrNoConfigMatch
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/replication/replication.go b/vendor/github.com/minio/minio-go/v7/pkg/replication/replication.go
new file mode 100644
index 0000000..0abbf6e
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/replication/replication.go
@@ -0,0 +1,971 @@
+/*
+ * MinIO Client (C) 2020 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 replication
+
+import (
+        "bytes"
+        "encoding/xml"
+        "fmt"
+        "math"
+        "strconv"
+        "strings"
+        "time"
+        "unicode/utf8"
+
+        "github.com/rs/xid"
+)
+
+var errInvalidFilter = fmt.Errorf("invalid filter")
+
+// OptionType specifies operation to be performed on config
+type OptionType string
+
+const (
+        // AddOption specifies addition of rule to config
+        AddOption OptionType = "Add"
+        // SetOption specifies modification of existing rule to config
+        SetOption OptionType = "Set"
+
+        // RemoveOption specifies rule options are for removing a rule
+        RemoveOption OptionType = "Remove"
+        // ImportOption is for getting current config
+        ImportOption OptionType = "Import"
+)
+
+// Options represents options to set a replication configuration rule
+type Options struct {
+        Op                      OptionType
+        RoleArn                 string
+        ID                      string
+        Prefix                  string
+        RuleStatus              string
+        Priority                string
+        TagString               string
+        StorageClass            string
+        DestBucket              string
+        IsTagSet                bool
+        IsSCSet                 bool
+        ReplicateDeletes        string // replicate versioned deletes
+        ReplicateDeleteMarkers  string // replicate soft deletes
+        ReplicaSync             string // replicate replica metadata modifications
+        ExistingObjectReplicate string
+}
+
+// Tags returns a slice of tags for a rule
+func (opts Options) Tags() ([]Tag, error) {
+        var tagList []Tag
+        tagTokens := strings.Split(opts.TagString, "&")
+        for _, tok := range tagTokens {
+                if tok == "" {
+                        break
+                }
+                kv := strings.SplitN(tok, "=", 2)
+                if len(kv) != 2 {
+                        return []Tag{}, fmt.Errorf("tags should be entered as comma separated k=v pairs")
+                }
+                tagList = append(tagList, Tag{
+                        Key:   kv[0],
+                        Value: kv[1],
+                })
+        }
+        return tagList, nil
+}
+
+// Config - replication configuration specified in
+// https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-add-config.html
+type Config struct {
+        XMLName xml.Name `xml:"ReplicationConfiguration" json:"-"`
+        Rules   []Rule   `xml:"Rule" json:"Rules"`
+        Role    string   `xml:"Role" json:"Role"`
+}
+
+// Empty returns true if config is not set
+func (c *Config) Empty() bool {
+        return len(c.Rules) == 0
+}
+
+// AddRule adds a new rule to existing replication config. If a rule exists with the
+// same ID, then the rule is replaced.
+func (c *Config) AddRule(opts Options) error {
+        priority, err := strconv.Atoi(opts.Priority)
+        if err != nil {
+                return err
+        }
+        var compatSw bool // true if RoleArn is used with new mc client and older minio version prior to multisite
+        if opts.RoleArn != "" {
+                tokens := strings.Split(opts.RoleArn, ":")
+                if len(tokens) != 6 {
+                        return fmt.Errorf("invalid format for replication Role Arn: %v", opts.RoleArn)
+                }
+                switch {
+                case strings.HasPrefix(opts.RoleArn, "arn:minio:replication") && len(c.Rules) == 0:
+                        c.Role = opts.RoleArn
+                        compatSw = true
+                case strings.HasPrefix(opts.RoleArn, "arn:aws:iam"):
+                        c.Role = opts.RoleArn
+                default:
+                        return fmt.Errorf("RoleArn invalid for AWS replication configuration: %v", opts.RoleArn)
+                }
+        }
+
+        var status Status
+        // toggle rule status for edit option
+        switch opts.RuleStatus {
+        case "enable":
+                status = Enabled
+        case "disable":
+                status = Disabled
+        default:
+                return fmt.Errorf("rule state should be either [enable|disable]")
+        }
+
+        tags, err := opts.Tags()
+        if err != nil {
+                return err
+        }
+        andVal := And{
+                Tags: tags,
+        }
+        filter := Filter{Prefix: opts.Prefix}
+        // only a single tag is set.
+        if opts.Prefix == "" && len(tags) == 1 {
+                filter.Tag = tags[0]
+        }
+        // both prefix and tag are present
+        if len(andVal.Tags) > 1 || opts.Prefix != "" {
+                filter.And = andVal
+                filter.And.Prefix = opts.Prefix
+                filter.Prefix = ""
+                filter.Tag = Tag{}
+        }
+        if opts.ID == "" {
+                opts.ID = xid.New().String()
+        }
+
+        destBucket := opts.DestBucket
+        // ref https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
+        if btokens := strings.Split(destBucket, ":"); len(btokens) != 6 {
+                if len(btokens) == 1 && compatSw {
+                        destBucket = fmt.Sprintf("arn:aws:s3:::%s", destBucket)
+                } else {
+                        return fmt.Errorf("destination bucket needs to be in Arn format")
+                }
+        }
+        dmStatus := Disabled
+        if opts.ReplicateDeleteMarkers != "" {
+                switch opts.ReplicateDeleteMarkers {
+                case "enable":
+                        dmStatus = Enabled
+                case "disable":
+                        dmStatus = Disabled
+                default:
+                        return fmt.Errorf("ReplicateDeleteMarkers should be either enable|disable")
+                }
+        }
+
+        vDeleteStatus := Disabled
+        if opts.ReplicateDeletes != "" {
+                switch opts.ReplicateDeletes {
+                case "enable":
+                        vDeleteStatus = Enabled
+                case "disable":
+                        vDeleteStatus = Disabled
+                default:
+                        return fmt.Errorf("ReplicateDeletes should be either enable|disable")
+                }
+        }
+        var replicaSync Status
+        // replica sync is by default Enabled, unless specified.
+        switch opts.ReplicaSync {
+        case "enable", "":
+                replicaSync = Enabled
+        case "disable":
+                replicaSync = Disabled
+        default:
+                return fmt.Errorf("replica metadata sync should be either [enable|disable]")
+        }
+
+        var existingStatus Status
+        if opts.ExistingObjectReplicate != "" {
+                switch opts.ExistingObjectReplicate {
+                case "enable":
+                        existingStatus = Enabled
+                case "disable", "":
+                        existingStatus = Disabled
+                default:
+                        return fmt.Errorf("existingObjectReplicate should be either enable|disable")
+                }
+        }
+        newRule := Rule{
+                ID:       opts.ID,
+                Priority: priority,
+                Status:   status,
+                Filter:   filter,
+                Destination: Destination{
+                        Bucket:       destBucket,
+                        StorageClass: opts.StorageClass,
+                },
+                DeleteMarkerReplication: DeleteMarkerReplication{Status: dmStatus},
+                DeleteReplication:       DeleteReplication{Status: vDeleteStatus},
+                // MinIO enables replica metadata syncing by default in the case of bi-directional replication to allow
+                // automatic failover as the expectation in this case is that replica and source should be identical.
+                // However AWS leaves this configurable https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-for-metadata-changes.html
+                SourceSelectionCriteria: SourceSelectionCriteria{
+                        ReplicaModifications: ReplicaModifications{
+                                Status: replicaSync,
+                        },
+                },
+                // By default disable existing object replication unless selected
+                ExistingObjectReplication: ExistingObjectReplication{
+                        Status: existingStatus,
+                },
+        }
+
+        // validate rule after overlaying priority for pre-existing rule being disabled.
+        if err := newRule.Validate(); err != nil {
+                return err
+        }
+        // if replication config uses RoleArn, migrate this to the destination element as target ARN for remote bucket for MinIO configuration
+        if c.Role != "" && !strings.HasPrefix(c.Role, "arn:aws:iam") && !compatSw {
+                for i := range c.Rules {
+                        c.Rules[i].Destination.Bucket = c.Role
+                }
+                c.Role = ""
+        }
+
+        for _, rule := range c.Rules {
+                if rule.Priority == newRule.Priority {
+                        return fmt.Errorf("priority must be unique. Replication configuration already has a rule with this priority")
+                }
+                if rule.ID == newRule.ID {
+                        return fmt.Errorf("a rule exists with this ID")
+                }
+        }
+
+        c.Rules = append(c.Rules, newRule)
+        return nil
+}
+
+// EditRule modifies an existing rule in replication config
+func (c *Config) EditRule(opts Options) error {
+        if opts.ID == "" {
+                return fmt.Errorf("rule ID missing")
+        }
+        // if replication config uses RoleArn, migrate this to the destination element as target ARN for remote bucket for non AWS.
+        if c.Role != "" && !strings.HasPrefix(c.Role, "arn:aws:iam") && len(c.Rules) > 1 {
+                for i := range c.Rules {
+                        c.Rules[i].Destination.Bucket = c.Role
+                }
+                c.Role = ""
+        }
+
+        rIdx := -1
+        var newRule Rule
+        for i, rule := range c.Rules {
+                if rule.ID == opts.ID {
+                        rIdx = i
+                        newRule = rule
+                        break
+                }
+        }
+        if rIdx < 0 {
+                return fmt.Errorf("rule with ID %s not found in replication configuration", opts.ID)
+        }
+        prefixChg := opts.Prefix != newRule.Prefix()
+        if opts.IsTagSet || prefixChg {
+                prefix := newRule.Prefix()
+                if prefix != opts.Prefix {
+                        prefix = opts.Prefix
+                }
+                tags := []Tag{newRule.Filter.Tag}
+                if len(newRule.Filter.And.Tags) != 0 {
+                        tags = newRule.Filter.And.Tags
+                }
+                var err error
+                if opts.IsTagSet {
+                        tags, err = opts.Tags()
+                        if err != nil {
+                                return err
+                        }
+                }
+                andVal := And{
+                        Tags: tags,
+                }
+
+                filter := Filter{Prefix: prefix}
+                // only a single tag is set.
+                if prefix == "" && len(tags) == 1 {
+                        filter.Tag = tags[0]
+                }
+                // both prefix and tag are present
+                if len(andVal.Tags) > 1 || prefix != "" {
+                        filter.And = andVal
+                        filter.And.Prefix = prefix
+                        filter.Prefix = ""
+                        filter.Tag = Tag{}
+                }
+                newRule.Filter = filter
+        }
+
+        // toggle rule status for edit option
+        if opts.RuleStatus != "" {
+                switch opts.RuleStatus {
+                case "enable":
+                        newRule.Status = Enabled
+                case "disable":
+                        newRule.Status = Disabled
+                default:
+                        return fmt.Errorf("rule state should be either [enable|disable]")
+                }
+        }
+        // set DeleteMarkerReplication rule status for edit option
+        if opts.ReplicateDeleteMarkers != "" {
+                switch opts.ReplicateDeleteMarkers {
+                case "enable":
+                        newRule.DeleteMarkerReplication.Status = Enabled
+                case "disable":
+                        newRule.DeleteMarkerReplication.Status = Disabled
+                default:
+                        return fmt.Errorf("ReplicateDeleteMarkers state should be either [enable|disable]")
+                }
+        }
+
+        // set DeleteReplication rule status for edit option. This is a MinIO specific
+        // option to replicate versioned deletes
+        if opts.ReplicateDeletes != "" {
+                switch opts.ReplicateDeletes {
+                case "enable":
+                        newRule.DeleteReplication.Status = Enabled
+                case "disable":
+                        newRule.DeleteReplication.Status = Disabled
+                default:
+                        return fmt.Errorf("ReplicateDeletes state should be either [enable|disable]")
+                }
+        }
+
+        if opts.ReplicaSync != "" {
+                switch opts.ReplicaSync {
+                case "enable", "":
+                        newRule.SourceSelectionCriteria.ReplicaModifications.Status = Enabled
+                case "disable":
+                        newRule.SourceSelectionCriteria.ReplicaModifications.Status = Disabled
+                default:
+                        return fmt.Errorf("replica metadata sync should be either [enable|disable]")
+                }
+        }
+
+        if opts.ExistingObjectReplicate != "" {
+                switch opts.ExistingObjectReplicate {
+                case "enable":
+                        newRule.ExistingObjectReplication.Status = Enabled
+                case "disable":
+                        newRule.ExistingObjectReplication.Status = Disabled
+                default:
+                        return fmt.Errorf("existingObjectsReplication state should be either [enable|disable]")
+                }
+        }
+        if opts.IsSCSet {
+                newRule.Destination.StorageClass = opts.StorageClass
+        }
+        if opts.Priority != "" {
+                priority, err := strconv.Atoi(opts.Priority)
+                if err != nil {
+                        return err
+                }
+                newRule.Priority = priority
+        }
+        if opts.DestBucket != "" {
+                destBucket := opts.DestBucket
+                // ref https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html
+                if btokens := strings.Split(opts.DestBucket, ":"); len(btokens) != 6 {
+                        return fmt.Errorf("destination bucket needs to be in Arn format")
+                }
+                newRule.Destination.Bucket = destBucket
+        }
+        // validate rule
+        if err := newRule.Validate(); err != nil {
+                return err
+        }
+        // ensure priority and destination bucket restrictions are not violated
+        for idx, rule := range c.Rules {
+                if rule.Priority == newRule.Priority && rIdx != idx {
+                        return fmt.Errorf("priority must be unique. Replication configuration already has a rule with this priority")
+                }
+                if rule.Destination.Bucket != newRule.Destination.Bucket && rule.ID == newRule.ID {
+                        return fmt.Errorf("invalid destination bucket for this rule")
+                }
+        }
+
+        c.Rules[rIdx] = newRule
+        return nil
+}
+
+// RemoveRule removes a rule from replication config.
+func (c *Config) RemoveRule(opts Options) error {
+        var newRules []Rule
+        ruleFound := false
+        for _, rule := range c.Rules {
+                if rule.ID != opts.ID {
+                        newRules = append(newRules, rule)
+                        continue
+                }
+                ruleFound = true
+        }
+        if !ruleFound {
+                return fmt.Errorf("Rule with ID %s not found", opts.ID)
+        }
+        if len(newRules) == 0 {
+                return fmt.Errorf("replication configuration should have at least one rule")
+        }
+        c.Rules = newRules
+        return nil
+}
+
+// Rule - a rule for replication configuration.
+type Rule struct {
+        XMLName                   xml.Name                  `xml:"Rule" json:"-"`
+        ID                        string                    `xml:"ID,omitempty"`
+        Status                    Status                    `xml:"Status"`
+        Priority                  int                       `xml:"Priority"`
+        DeleteMarkerReplication   DeleteMarkerReplication   `xml:"DeleteMarkerReplication"`
+        DeleteReplication         DeleteReplication         `xml:"DeleteReplication"`
+        Destination               Destination               `xml:"Destination"`
+        Filter                    Filter                    `xml:"Filter" json:"Filter"`
+        SourceSelectionCriteria   SourceSelectionCriteria   `xml:"SourceSelectionCriteria" json:"SourceSelectionCriteria"`
+        ExistingObjectReplication ExistingObjectReplication `xml:"ExistingObjectReplication,omitempty" json:"ExistingObjectReplication,omitempty"`
+}
+
+// Validate validates the rule for correctness
+func (r Rule) Validate() error {
+        if err := r.validateID(); err != nil {
+                return err
+        }
+        if err := r.validateStatus(); err != nil {
+                return err
+        }
+        if err := r.validateFilter(); err != nil {
+                return err
+        }
+
+        if r.Priority < 0 && r.Status == Enabled {
+                return fmt.Errorf("priority must be set for the rule")
+        }
+
+        if err := r.validateStatus(); err != nil {
+                return err
+        }
+        return r.ExistingObjectReplication.Validate()
+}
+
+// validateID - checks if ID is valid or not.
+func (r Rule) validateID() error {
+        // cannot be longer than 255 characters
+        if len(r.ID) > 255 {
+                return fmt.Errorf("ID must be less than 255 characters")
+        }
+        return nil
+}
+
+// validateStatus - checks if status is valid or not.
+func (r Rule) validateStatus() error {
+        // Status can't be empty
+        if len(r.Status) == 0 {
+                return fmt.Errorf("status cannot be empty")
+        }
+
+        // Status must be one of Enabled or Disabled
+        if r.Status != Enabled && r.Status != Disabled {
+                return fmt.Errorf("status must be set to either Enabled or Disabled")
+        }
+        return nil
+}
+
+func (r Rule) validateFilter() error {
+        return r.Filter.Validate()
+}
+
+// Prefix - a rule can either have prefix under <filter></filter> or under
+// <filter><and></and></filter>. This method returns the prefix from the
+// location where it is available
+func (r Rule) Prefix() string {
+        if r.Filter.Prefix != "" {
+                return r.Filter.Prefix
+        }
+        return r.Filter.And.Prefix
+}
+
+// Tags - a rule can either have tag under <filter></filter> or under
+// <filter><and></and></filter>. This method returns all the tags from the
+// rule in the format tag1=value1&tag2=value2
+func (r Rule) Tags() string {
+        ts := []Tag{r.Filter.Tag}
+        if len(r.Filter.And.Tags) != 0 {
+                ts = r.Filter.And.Tags
+        }
+
+        var buf bytes.Buffer
+        for _, t := range ts {
+                if buf.Len() > 0 {
+                        buf.WriteString("&")
+                }
+                buf.WriteString(t.String())
+        }
+        return buf.String()
+}
+
+// Filter - a filter for a replication configuration Rule.
+type Filter struct {
+        XMLName xml.Name `xml:"Filter" json:"-"`
+        Prefix  string   `json:"Prefix,omitempty"`
+        And     And      `xml:"And,omitempty" json:"And,omitempty"`
+        Tag     Tag      `xml:"Tag,omitempty" json:"Tag,omitempty"`
+}
+
+// Validate - validates the filter element
+func (f Filter) Validate() error {
+        // A Filter must have exactly one of Prefix, Tag, or And specified.
+        if !f.And.isEmpty() {
+                if f.Prefix != "" {
+                        return errInvalidFilter
+                }
+                if !f.Tag.IsEmpty() {
+                        return errInvalidFilter
+                }
+        }
+        if f.Prefix != "" {
+                if !f.Tag.IsEmpty() {
+                        return errInvalidFilter
+                }
+        }
+        if !f.Tag.IsEmpty() {
+                if err := f.Tag.Validate(); err != nil {
+                        return err
+                }
+        }
+        return nil
+}
+
+// Tag - a tag for a replication configuration Rule filter.
+type Tag struct {
+        XMLName xml.Name `json:"-"`
+        Key     string   `xml:"Key,omitempty" json:"Key,omitempty"`
+        Value   string   `xml:"Value,omitempty" json:"Value,omitempty"`
+}
+
+func (tag Tag) String() string {
+        if tag.IsEmpty() {
+                return ""
+        }
+        return tag.Key + "=" + tag.Value
+}
+
+// IsEmpty returns whether this tag is empty or not.
+func (tag Tag) IsEmpty() bool {
+        return tag.Key == ""
+}
+
+// Validate checks this tag.
+func (tag Tag) Validate() error {
+        if len(tag.Key) == 0 || utf8.RuneCountInString(tag.Key) > 128 {
+                return fmt.Errorf("invalid Tag Key")
+        }
+
+        if utf8.RuneCountInString(tag.Value) > 256 {
+                return fmt.Errorf("invalid Tag Value")
+        }
+        return nil
+}
+
+// Destination - destination in ReplicationConfiguration.
+type Destination struct {
+        XMLName      xml.Name `xml:"Destination" json:"-"`
+        Bucket       string   `xml:"Bucket" json:"Bucket"`
+        StorageClass string   `xml:"StorageClass,omitempty" json:"StorageClass,omitempty"`
+}
+
+// And - a tag to combine a prefix and multiple tags for replication configuration rule.
+type And struct {
+        XMLName xml.Name `xml:"And,omitempty" json:"-"`
+        Prefix  string   `xml:"Prefix,omitempty" json:"Prefix,omitempty"`
+        Tags    []Tag    `xml:"Tag,omitempty" json:"Tag,omitempty"`
+}
+
+// isEmpty returns true if Tags field is null
+func (a And) isEmpty() bool {
+        return len(a.Tags) == 0 && a.Prefix == ""
+}
+
+// Status represents Enabled/Disabled status
+type Status string
+
+// Supported status types
+const (
+        Enabled  Status = "Enabled"
+        Disabled Status = "Disabled"
+)
+
+// DeleteMarkerReplication - whether delete markers are replicated - https://docs.aws.amazon.com/AmazonS3/latest/dev/replication-add-config.html
+type DeleteMarkerReplication struct {
+        Status Status `xml:"Status" json:"Status"` // should be set to "Disabled" by default
+}
+
+// IsEmpty returns true if DeleteMarkerReplication is not set
+func (d DeleteMarkerReplication) IsEmpty() bool {
+        return len(d.Status) == 0
+}
+
+// DeleteReplication - whether versioned deletes are replicated - this
+// is a MinIO specific extension
+type DeleteReplication struct {
+        Status Status `xml:"Status" json:"Status"` // should be set to "Disabled" by default
+}
+
+// IsEmpty returns true if DeleteReplication is not set
+func (d DeleteReplication) IsEmpty() bool {
+        return len(d.Status) == 0
+}
+
+// ReplicaModifications specifies if replica modification sync is enabled
+type ReplicaModifications struct {
+        Status Status `xml:"Status" json:"Status"` // should be set to "Enabled" by default
+}
+
+// SourceSelectionCriteria - specifies additional source selection criteria in ReplicationConfiguration.
+type SourceSelectionCriteria struct {
+        ReplicaModifications ReplicaModifications `xml:"ReplicaModifications" json:"ReplicaModifications"`
+}
+
+// IsValid - checks whether SourceSelectionCriteria is valid or not.
+func (s SourceSelectionCriteria) IsValid() bool {
+        return s.ReplicaModifications.Status == Enabled || s.ReplicaModifications.Status == Disabled
+}
+
+// Validate source selection criteria
+func (s SourceSelectionCriteria) Validate() error {
+        if (s == SourceSelectionCriteria{}) {
+                return nil
+        }
+        if !s.IsValid() {
+                return fmt.Errorf("invalid ReplicaModification status")
+        }
+        return nil
+}
+
+// ExistingObjectReplication - whether existing object replication is enabled
+type ExistingObjectReplication struct {
+        Status Status `xml:"Status"` // should be set to "Disabled" by default
+}
+
+// IsEmpty returns true if DeleteMarkerReplication is not set
+func (e ExistingObjectReplication) IsEmpty() bool {
+        return len(e.Status) == 0
+}
+
+// Validate validates whether the status is disabled.
+func (e ExistingObjectReplication) Validate() error {
+        if e.IsEmpty() {
+                return nil
+        }
+        if e.Status != Disabled && e.Status != Enabled {
+                return fmt.Errorf("invalid ExistingObjectReplication status")
+        }
+        return nil
+}
+
+// TargetMetrics represents inline replication metrics
+// such as pending, failed and completed bytes in total for a bucket remote target
+type TargetMetrics struct {
+        // Completed count
+        ReplicatedCount uint64 `json:"replicationCount,omitempty"`
+        // Completed size in bytes
+        ReplicatedSize uint64 `json:"completedReplicationSize,omitempty"`
+        // Bandwidth limit in bytes/sec for this target
+        BandWidthLimitInBytesPerSecond int64 `json:"limitInBits,omitempty"`
+        // Current bandwidth used in bytes/sec for this target
+        CurrentBandwidthInBytesPerSecond float64 `json:"currentBandwidth,omitempty"`
+        // errors seen in replication in last minute, hour and total
+        Failed TimedErrStats `json:"failed,omitempty"`
+        // Deprecated fields
+        // Pending size in bytes
+        PendingSize uint64 `json:"pendingReplicationSize,omitempty"`
+        // Total Replica size in bytes
+        ReplicaSize uint64 `json:"replicaSize,omitempty"`
+        // Failed size in bytes
+        FailedSize uint64 `json:"failedReplicationSize,omitempty"`
+        // Total number of pending operations including metadata updates
+        PendingCount uint64 `json:"pendingReplicationCount,omitempty"`
+        // Total number of failed operations including metadata updates
+        FailedCount uint64 `json:"failedReplicationCount,omitempty"`
+}
+
+// Metrics represents inline replication metrics for a bucket.
+type Metrics struct {
+        Stats map[string]TargetMetrics
+        // Completed size in bytes  across targets
+        ReplicatedSize uint64 `json:"completedReplicationSize,omitempty"`
+        // Total Replica size in bytes  across targets
+        ReplicaSize uint64 `json:"replicaSize,omitempty"`
+        // Total Replica counts
+        ReplicaCount int64 `json:"replicaCount,omitempty"`
+        // Total Replicated count
+        ReplicatedCount int64 `json:"replicationCount,omitempty"`
+        // errors seen in replication in last minute, hour and total
+        Errors TimedErrStats `json:"failed,omitempty"`
+        // Total number of entries that are queued for replication
+        QStats InQueueMetric `json:"queued"`
+        // Deprecated fields
+        // Total Pending size in bytes across targets
+        PendingSize uint64 `json:"pendingReplicationSize,omitempty"`
+        // Failed size in bytes  across targets
+        FailedSize uint64 `json:"failedReplicationSize,omitempty"`
+        // Total number of pending operations including metadata updates across targets
+        PendingCount uint64 `json:"pendingReplicationCount,omitempty"`
+        // Total number of failed operations including metadata updates across targets
+        FailedCount uint64 `json:"failedReplicationCount,omitempty"`
+}
+
+// RStat - has count and bytes for replication metrics
+type RStat struct {
+        Count float64 `json:"count"`
+        Bytes int64   `json:"bytes"`
+}
+
+// Add two RStat
+func (r RStat) Add(r1 RStat) RStat {
+        return RStat{
+                Count: r.Count + r1.Count,
+                Bytes: r.Bytes + r1.Bytes,
+        }
+}
+
+// TimedErrStats holds error stats for a time period
+type TimedErrStats struct {
+        LastMinute RStat `json:"lastMinute"`
+        LastHour   RStat `json:"lastHour"`
+        Totals     RStat `json:"totals"`
+}
+
+// Add two TimedErrStats
+func (te TimedErrStats) Add(o TimedErrStats) TimedErrStats {
+        return TimedErrStats{
+                LastMinute: te.LastMinute.Add(o.LastMinute),
+                LastHour:   te.LastHour.Add(o.LastHour),
+                Totals:     te.Totals.Add(o.Totals),
+        }
+}
+
+// ResyncTargetsInfo provides replication target information to resync replicated data.
+type ResyncTargetsInfo struct {
+        Targets []ResyncTarget `json:"target,omitempty"`
+}
+
+// ResyncTarget provides the replica resources and resetID to initiate resync replication.
+type ResyncTarget struct {
+        Arn       string    `json:"arn"`
+        ResetID   string    `json:"resetid"`
+        StartTime time.Time `json:"startTime,omitempty"`
+        EndTime   time.Time `json:"endTime,omitempty"`
+        // Status of resync operation
+        ResyncStatus string `json:"resyncStatus,omitempty"`
+        // Completed size in bytes
+        ReplicatedSize int64 `json:"completedReplicationSize,omitempty"`
+        // Failed size in bytes
+        FailedSize int64 `json:"failedReplicationSize,omitempty"`
+        // Total number of failed operations
+        FailedCount int64 `json:"failedReplicationCount,omitempty"`
+        // Total number of completed operations
+        ReplicatedCount int64 `json:"replicationCount,omitempty"`
+        // Last bucket/object replicated.
+        Bucket string `json:"bucket,omitempty"`
+        Object string `json:"object,omitempty"`
+}
+
+// XferStats holds transfer rate info for uploads/sec
+type XferStats struct {
+        AvgRate  float64 `json:"avgRate"`
+        PeakRate float64 `json:"peakRate"`
+        CurrRate float64 `json:"currRate"`
+}
+
+// Merge two XferStats
+func (x *XferStats) Merge(x1 XferStats) {
+        x.AvgRate += x1.AvgRate
+        x.PeakRate += x1.PeakRate
+        x.CurrRate += x1.CurrRate
+}
+
+// QStat holds count and bytes for objects in replication queue
+type QStat struct {
+        Count float64 `json:"count"`
+        Bytes float64 `json:"bytes"`
+}
+
+// Add 2 QStat entries
+func (q *QStat) Add(q1 QStat) {
+        q.Count += q1.Count
+        q.Bytes += q1.Bytes
+}
+
+// InQueueMetric holds stats for objects in replication queue
+type InQueueMetric struct {
+        Curr QStat `json:"curr" msg:"cq"`
+        Avg  QStat `json:"avg" msg:"aq"`
+        Max  QStat `json:"peak" msg:"pq"`
+}
+
+// MetricName name of replication metric
+type MetricName string
+
+const (
+        // Large is a metric name for large objects >=128MiB
+        Large MetricName = "Large"
+        // Small is a metric name for  objects <128MiB size
+        Small MetricName = "Small"
+        // Total is a metric name for total objects
+        Total MetricName = "Total"
+)
+
+// WorkerStat has stats on number of replication workers
+type WorkerStat struct {
+        Curr int32   `json:"curr"`
+        Avg  float32 `json:"avg"`
+        Max  int32   `json:"max"`
+}
+
+// ReplMRFStats holds stats of MRF backlog saved to disk in the last 5 minutes
+// and number of entries that failed replication after 3 retries
+type ReplMRFStats struct {
+        LastFailedCount uint64 `json:"failedCount_last5min"`
+        // Count of unreplicated entries that were dropped after MRF retry limit reached since cluster start.
+        TotalDroppedCount uint64 `json:"droppedCount_since_uptime"`
+        // Bytes of unreplicated entries that were dropped after MRF retry limit reached since cluster start.
+        TotalDroppedBytes uint64 `json:"droppedBytes_since_uptime"`
+}
+
+// ReplQNodeStats holds stats for a node in replication queue
+type ReplQNodeStats struct {
+        NodeName string     `json:"nodeName"`
+        Uptime   int64      `json:"uptime"`
+        Workers  WorkerStat `json:"activeWorkers"`
+
+        XferStats    map[MetricName]XferStats            `json:"transferSummary"`
+        TgtXferStats map[string]map[MetricName]XferStats `json:"tgtTransferStats"`
+
+        QStats   InQueueMetric `json:"queueStats"`
+        MRFStats ReplMRFStats  `json:"mrfStats"`
+}
+
+// ReplQueueStats holds stats for replication queue across nodes
+type ReplQueueStats struct {
+        Nodes []ReplQNodeStats `json:"nodes"`
+}
+
+// Workers returns number of workers across all nodes
+func (q ReplQueueStats) Workers() (tot WorkerStat) {
+        for _, node := range q.Nodes {
+                tot.Avg += node.Workers.Avg
+                tot.Curr += node.Workers.Curr
+                if tot.Max < node.Workers.Max {
+                        tot.Max = node.Workers.Max
+                }
+        }
+        if len(q.Nodes) > 0 {
+                tot.Avg /= float32(len(q.Nodes))
+                tot.Curr /= int32(len(q.Nodes))
+        }
+        return tot
+}
+
+// qStatSummary returns cluster level stats for objects in replication queue
+func (q ReplQueueStats) qStatSummary() InQueueMetric {
+        m := InQueueMetric{}
+        for _, v := range q.Nodes {
+                m.Avg.Add(v.QStats.Avg)
+                m.Curr.Add(v.QStats.Curr)
+                if m.Max.Count < v.QStats.Max.Count {
+                        m.Max.Add(v.QStats.Max)
+                }
+        }
+        return m
+}
+
+// ReplQStats holds stats for objects in replication queue
+type ReplQStats struct {
+        Uptime  int64      `json:"uptime"`
+        Workers WorkerStat `json:"workers"`
+
+        XferStats    map[MetricName]XferStats            `json:"xferStats"`
+        TgtXferStats map[string]map[MetricName]XferStats `json:"tgtXferStats"`
+
+        QStats   InQueueMetric `json:"qStats"`
+        MRFStats ReplMRFStats  `json:"mrfStats"`
+}
+
+// QStats returns cluster level stats for objects in replication queue
+func (q ReplQueueStats) QStats() (r ReplQStats) {
+        r.QStats = q.qStatSummary()
+        r.XferStats = make(map[MetricName]XferStats)
+        r.TgtXferStats = make(map[string]map[MetricName]XferStats)
+        r.Workers = q.Workers()
+
+        for _, node := range q.Nodes {
+                for arn := range node.TgtXferStats {
+                        xmap, ok := node.TgtXferStats[arn]
+                        if !ok {
+                                xmap = make(map[MetricName]XferStats)
+                        }
+                        for m, v := range xmap {
+                                st, ok := r.XferStats[m]
+                                if !ok {
+                                        st = XferStats{}
+                                }
+                                st.AvgRate += v.AvgRate
+                                st.CurrRate += v.CurrRate
+                                st.PeakRate = math.Max(st.PeakRate, v.PeakRate)
+                                if _, ok := r.TgtXferStats[arn]; !ok {
+                                        r.TgtXferStats[arn] = make(map[MetricName]XferStats)
+                                }
+                                r.TgtXferStats[arn][m] = st
+                        }
+                }
+                for k, v := range node.XferStats {
+                        st, ok := r.XferStats[k]
+                        if !ok {
+                                st = XferStats{}
+                        }
+                        st.AvgRate += v.AvgRate
+                        st.CurrRate += v.CurrRate
+                        st.PeakRate = math.Max(st.PeakRate, v.PeakRate)
+                        r.XferStats[k] = st
+                }
+                r.MRFStats.LastFailedCount += node.MRFStats.LastFailedCount
+                r.MRFStats.TotalDroppedCount += node.MRFStats.TotalDroppedCount
+                r.MRFStats.TotalDroppedBytes += node.MRFStats.TotalDroppedBytes
+                r.Uptime += node.Uptime
+        }
+        if len(q.Nodes) > 0 {
+                r.Uptime /= int64(len(q.Nodes)) // average uptime
+        }
+        return
+}
+
+// MetricsV2 represents replication metrics for a bucket.
+type MetricsV2 struct {
+        Uptime       int64          `json:"uptime"`
+        CurrentStats Metrics        `json:"currStats"`
+        QueueStats   ReplQueueStats `json:"queueStats"`
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/s3utils/utils.go b/vendor/github.com/minio/minio-go/v7/pkg/s3utils/utils.go
new file mode 100644
index 0000000..056e78a
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/s3utils/utils.go
@@ -0,0 +1,411 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2020 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 s3utils
+
+import (
+        "bytes"
+        "encoding/hex"
+        "errors"
+        "net"
+        "net/url"
+        "regexp"
+        "sort"
+        "strings"
+        "unicode/utf8"
+)
+
+// Sentinel URL is the default url value which is invalid.
+var sentinelURL = url.URL{}
+
+// IsValidDomain validates if input string is a valid domain name.
+func IsValidDomain(host string) bool {
+        // See RFC 1035, RFC 3696.
+        host = strings.TrimSpace(host)
+        if len(host) == 0 || len(host) > 255 {
+                return false
+        }
+        // host cannot start or end with "-"
+        if host[len(host)-1:] == "-" || host[:1] == "-" {
+                return false
+        }
+        // host cannot start or end with "_"
+        if host[len(host)-1:] == "_" || host[:1] == "_" {
+                return false
+        }
+        // host cannot start with a "."
+        if host[:1] == "." {
+                return false
+        }
+        // All non alphanumeric characters are invalid.
+        if strings.ContainsAny(host, "`~!@#$%^&*()+={}[]|\\\"';:><?/") {
+                return false
+        }
+        // No need to regexp match, since the list is non-exhaustive.
+        // We let it valid and fail later.
+        return true
+}
+
+// IsValidIP parses input string for ip address validity.
+func IsValidIP(ip string) bool {
+        return net.ParseIP(ip) != nil
+}
+
+// IsVirtualHostSupported - verifies if bucketName can be part of
+// virtual host. Currently only Amazon S3 and Google Cloud Storage
+// would support this.
+func IsVirtualHostSupported(endpointURL url.URL, bucketName string) bool {
+        if endpointURL == sentinelURL {
+                return false
+        }
+        // bucketName can be valid but '.' in the hostname will fail SSL
+        // certificate validation. So do not use host-style for such buckets.
+        if endpointURL.Scheme == "https" && strings.Contains(bucketName, ".") {
+                return false
+        }
+        // Return true for all other cases
+        return IsAmazonEndpoint(endpointURL) || IsGoogleEndpoint(endpointURL) || IsAliyunOSSEndpoint(endpointURL)
+}
+
+// Refer for region styles - https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region
+
+// amazonS3HostHyphen - regular expression used to determine if an arg is s3 host in hyphenated style.
+var amazonS3HostHyphen = regexp.MustCompile(`^s3-(.*?).amazonaws.com$`)
+
+// amazonS3HostDualStack - regular expression used to determine if an arg is s3 host dualstack.
+var amazonS3HostDualStack = regexp.MustCompile(`^s3.dualstack.(.*?).amazonaws.com$`)
+
+// amazonS3HostFIPS - regular expression used to determine if an arg is s3 FIPS host.
+var amazonS3HostFIPS = regexp.MustCompile(`^s3-fips.(.*?).amazonaws.com$`)
+
+// amazonS3HostFIPSDualStack - regular expression used to determine if an arg is s3 FIPS host dualstack.
+var amazonS3HostFIPSDualStack = regexp.MustCompile(`^s3-fips.dualstack.(.*?).amazonaws.com$`)
+
+// amazonS3HostDot - regular expression used to determine if an arg is s3 host in . style.
+var amazonS3HostDot = regexp.MustCompile(`^s3.(.*?).amazonaws.com$`)
+
+// amazonS3ChinaHost - regular expression used to determine if the arg is s3 china host.
+var amazonS3ChinaHost = regexp.MustCompile(`^s3.(cn.*?).amazonaws.com.cn$`)
+
+// amazonS3ChinaHostDualStack - regular expression used to determine if the arg is s3 china host dualstack.
+var amazonS3ChinaHostDualStack = regexp.MustCompile(`^s3.dualstack.(cn.*?).amazonaws.com.cn$`)
+
+// Regular expression used to determine if the arg is elb host.
+var elbAmazonRegex = regexp.MustCompile(`elb(.*?).amazonaws.com$`)
+
+// Regular expression used to determine if the arg is elb host in china.
+var elbAmazonCnRegex = regexp.MustCompile(`elb(.*?).amazonaws.com.cn$`)
+
+// amazonS3HostPrivateLink - regular expression used to determine if an arg is s3 host in AWS PrivateLink interface endpoints style
+var amazonS3HostPrivateLink = regexp.MustCompile(`^(?:bucket|accesspoint).vpce-.*?.s3.(.*?).vpce.amazonaws.com$`)
+
+// GetRegionFromURL - returns a region from url host.
+func GetRegionFromURL(endpointURL url.URL) string {
+        if endpointURL == sentinelURL {
+                return ""
+        }
+        if endpointURL.Host == "s3-external-1.amazonaws.com" {
+                return ""
+        }
+
+        // if elb's are used we cannot calculate which region it may be, just return empty.
+        if elbAmazonRegex.MatchString(endpointURL.Host) || elbAmazonCnRegex.MatchString(endpointURL.Host) {
+                return ""
+        }
+
+        // We check for FIPS dualstack matching first to avoid the non-greedy
+        // regex for FIPS non-dualstack matching a dualstack URL
+        parts := amazonS3HostFIPSDualStack.FindStringSubmatch(endpointURL.Host)
+        if len(parts) > 1 {
+                return parts[1]
+        }
+
+        parts = amazonS3HostFIPS.FindStringSubmatch(endpointURL.Host)
+        if len(parts) > 1 {
+                return parts[1]
+        }
+
+        parts = amazonS3HostDualStack.FindStringSubmatch(endpointURL.Host)
+        if len(parts) > 1 {
+                return parts[1]
+        }
+
+        parts = amazonS3HostHyphen.FindStringSubmatch(endpointURL.Host)
+        if len(parts) > 1 {
+                return parts[1]
+        }
+
+        parts = amazonS3ChinaHost.FindStringSubmatch(endpointURL.Host)
+        if len(parts) > 1 {
+                return parts[1]
+        }
+
+        parts = amazonS3ChinaHostDualStack.FindStringSubmatch(endpointURL.Host)
+        if len(parts) > 1 {
+                return parts[1]
+        }
+
+        parts = amazonS3HostDot.FindStringSubmatch(endpointURL.Host)
+        if len(parts) > 1 {
+                return parts[1]
+        }
+
+        parts = amazonS3HostPrivateLink.FindStringSubmatch(endpointURL.Host)
+        if len(parts) > 1 {
+                return parts[1]
+        }
+
+        return ""
+}
+
+// IsAliyunOSSEndpoint - Match if it is exactly Aliyun OSS endpoint.
+func IsAliyunOSSEndpoint(endpointURL url.URL) bool {
+        return strings.HasSuffix(endpointURL.Host, "aliyuncs.com")
+}
+
+// IsAmazonEndpoint - Match if it is exactly Amazon S3 endpoint.
+func IsAmazonEndpoint(endpointURL url.URL) bool {
+        if endpointURL.Host == "s3-external-1.amazonaws.com" || endpointURL.Host == "s3.amazonaws.com" {
+                return true
+        }
+        return GetRegionFromURL(endpointURL) != ""
+}
+
+// IsAmazonGovCloudEndpoint - Match if it is exactly Amazon S3 GovCloud endpoint.
+func IsAmazonGovCloudEndpoint(endpointURL url.URL) bool {
+        if endpointURL == sentinelURL {
+                return false
+        }
+        return (endpointURL.Host == "s3-us-gov-west-1.amazonaws.com" ||
+                endpointURL.Host == "s3-us-gov-east-1.amazonaws.com" ||
+                IsAmazonFIPSGovCloudEndpoint(endpointURL))
+}
+
+// IsAmazonFIPSGovCloudEndpoint - match if the endpoint is FIPS and GovCloud.
+func IsAmazonFIPSGovCloudEndpoint(endpointURL url.URL) bool {
+        if endpointURL == sentinelURL {
+                return false
+        }
+        return IsAmazonFIPSEndpoint(endpointURL) && strings.Contains(endpointURL.Host, "us-gov-")
+}
+
+// IsAmazonFIPSEndpoint - Match if it is exactly Amazon S3 FIPS endpoint.
+// See https://aws.amazon.com/compliance/fips.
+func IsAmazonFIPSEndpoint(endpointURL url.URL) bool {
+        if endpointURL == sentinelURL {
+                return false
+        }
+        return strings.HasPrefix(endpointURL.Host, "s3-fips") && strings.HasSuffix(endpointURL.Host, ".amazonaws.com")
+}
+
+// IsAmazonPrivateLinkEndpoint - Match if it is exactly Amazon S3 PrivateLink interface endpoint
+// See https://docs.aws.amazon.com/AmazonS3/latest/userguide/privatelink-interface-endpoints.html.
+func IsAmazonPrivateLinkEndpoint(endpointURL url.URL) bool {
+        if endpointURL == sentinelURL {
+                return false
+        }
+        return amazonS3HostPrivateLink.MatchString(endpointURL.Host)
+}
+
+// IsGoogleEndpoint - Match if it is exactly Google cloud storage endpoint.
+func IsGoogleEndpoint(endpointURL url.URL) bool {
+        if endpointURL == sentinelURL {
+                return false
+        }
+        return endpointURL.Host == "storage.googleapis.com"
+}
+
+// Expects ascii encoded strings - from output of urlEncodePath
+func percentEncodeSlash(s string) string {
+        return strings.ReplaceAll(s, "/", "%2F")
+}
+
+// QueryEncode - encodes query values in their URL encoded form. In
+// addition to the percent encoding performed by urlEncodePath() used
+// here, it also percent encodes '/' (forward slash)
+func QueryEncode(v url.Values) string {
+        if v == nil {
+                return ""
+        }
+        var buf bytes.Buffer
+        keys := make([]string, 0, len(v))
+        for k := range v {
+                keys = append(keys, k)
+        }
+        sort.Strings(keys)
+        for _, k := range keys {
+                vs := v[k]
+                prefix := percentEncodeSlash(EncodePath(k)) + "="
+                for _, v := range vs {
+                        if buf.Len() > 0 {
+                                buf.WriteByte('&')
+                        }
+                        buf.WriteString(prefix)
+                        buf.WriteString(percentEncodeSlash(EncodePath(v)))
+                }
+        }
+        return buf.String()
+}
+
+// TagDecode - decodes canonical tag into map of key and value.
+func TagDecode(ctag string) map[string]string {
+        if ctag == "" {
+                return map[string]string{}
+        }
+        tags := strings.Split(ctag, "&")
+        tagMap := make(map[string]string, len(tags))
+        var err error
+        for _, tag := range tags {
+                kvs := strings.SplitN(tag, "=", 2)
+                if len(kvs) == 0 {
+                        return map[string]string{}
+                }
+                if len(kvs) == 1 {
+                        return map[string]string{}
+                }
+                tagMap[kvs[0]], err = url.PathUnescape(kvs[1])
+                if err != nil {
+                        continue
+                }
+        }
+        return tagMap
+}
+
+// TagEncode - encodes tag values in their URL encoded form. In
+// addition to the percent encoding performed by urlEncodePath() used
+// here, it also percent encodes '/' (forward slash)
+func TagEncode(tags map[string]string) string {
+        if tags == nil {
+                return ""
+        }
+        values := url.Values{}
+        for k, v := range tags {
+                values[k] = []string{v}
+        }
+        return QueryEncode(values)
+}
+
+// if object matches reserved string, no need to encode them
+var reservedObjectNames = regexp.MustCompile("^[a-zA-Z0-9-_.~/]+$")
+
+// EncodePath encode the strings from UTF-8 byte representations to HTML hex escape sequences
+//
+// This is necessary since regular url.Parse() and url.Encode() functions do not support UTF-8
+// non english characters cannot be parsed due to the nature in which url.Encode() is written
+//
+// This function on the other hand is a direct replacement for url.Encode() technique to support
+// pretty much every UTF-8 character.
+func EncodePath(pathName string) string {
+        if reservedObjectNames.MatchString(pathName) {
+                return pathName
+        }
+        var encodedPathname strings.Builder
+        for _, s := range pathName {
+                if 'A' <= s && s <= 'Z' || 'a' <= s && s <= 'z' || '0' <= s && s <= '9' { // §2.3 Unreserved characters (mark)
+                        encodedPathname.WriteRune(s)
+                        continue
+                }
+                switch s {
+                case '-', '_', '.', '~', '/': // §2.3 Unreserved characters (mark)
+                        encodedPathname.WriteRune(s)
+                        continue
+                default:
+                        l := utf8.RuneLen(s)
+                        if l < 0 {
+                                // if utf8 cannot convert return the same string as is
+                                return pathName
+                        }
+                        u := make([]byte, l)
+                        utf8.EncodeRune(u, s)
+                        for _, r := range u {
+                                hex := hex.EncodeToString([]byte{r})
+                                encodedPathname.WriteString("%" + strings.ToUpper(hex))
+                        }
+                }
+        }
+        return encodedPathname.String()
+}
+
+// We support '.' with bucket names but we fallback to using path
+// style requests instead for such buckets.
+var (
+        validBucketName       = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9\.\-\_\:]{1,61}[A-Za-z0-9]$`)
+        validBucketNameStrict = regexp.MustCompile(`^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$`)
+        ipAddress             = regexp.MustCompile(`^(\d+\.){3}\d+$`)
+)
+
+// Common checker for both stricter and basic validation.
+func checkBucketNameCommon(bucketName string, strict bool) (err error) {
+        if strings.TrimSpace(bucketName) == "" {
+                return errors.New("Bucket name cannot be empty")
+        }
+        if len(bucketName) < 3 {
+                return errors.New("Bucket name cannot be shorter than 3 characters")
+        }
+        if len(bucketName) > 63 {
+                return errors.New("Bucket name cannot be longer than 63 characters")
+        }
+        if ipAddress.MatchString(bucketName) {
+                return errors.New("Bucket name cannot be an ip address")
+        }
+        if strings.Contains(bucketName, "..") || strings.Contains(bucketName, ".-") || strings.Contains(bucketName, "-.") {
+                return errors.New("Bucket name contains invalid characters")
+        }
+        if strict {
+                if !validBucketNameStrict.MatchString(bucketName) {
+                        err = errors.New("Bucket name contains invalid characters")
+                }
+                return err
+        }
+        if !validBucketName.MatchString(bucketName) {
+                err = errors.New("Bucket name contains invalid characters")
+        }
+        return err
+}
+
+// CheckValidBucketName - checks if we have a valid input bucket name.
+func CheckValidBucketName(bucketName string) (err error) {
+        return checkBucketNameCommon(bucketName, false)
+}
+
+// CheckValidBucketNameStrict - checks if we have a valid input bucket name.
+// This is a stricter version.
+// - http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html
+func CheckValidBucketNameStrict(bucketName string) (err error) {
+        return checkBucketNameCommon(bucketName, true)
+}
+
+// CheckValidObjectNamePrefix - checks if we have a valid input object name prefix.
+//   - http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html
+func CheckValidObjectNamePrefix(objectName string) error {
+        if len(objectName) > 1024 {
+                return errors.New("Object name cannot be longer than 1024 characters")
+        }
+        if !utf8.ValidString(objectName) {
+                return errors.New("Object name with non UTF-8 strings are not supported")
+        }
+        return nil
+}
+
+// CheckValidObjectName - checks if we have a valid input object name.
+//   - http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html
+func CheckValidObjectName(objectName string) error {
+        if strings.TrimSpace(objectName) == "" {
+                return errors.New("Object name cannot be empty")
+        }
+        return CheckValidObjectNamePrefix(objectName)
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/set/stringset.go b/vendor/github.com/minio/minio-go/v7/pkg/set/stringset.go
new file mode 100644
index 0000000..c35e58e
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/set/stringset.go
@@ -0,0 +1,200 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 set
+
+import (
+        "fmt"
+        "sort"
+
+        jsoniter "github.com/json-iterator/go"
+)
+
+// StringSet - uses map as set of strings.
+type StringSet map[string]struct{}
+
+var json = jsoniter.ConfigCompatibleWithStandardLibrary
+
+// ToSlice - returns StringSet as string slice.
+func (set StringSet) ToSlice() []string {
+        keys := make([]string, 0, len(set))
+        for k := range set {
+                keys = append(keys, k)
+        }
+        sort.Strings(keys)
+        return keys
+}
+
+// IsEmpty - returns whether the set is empty or not.
+func (set StringSet) IsEmpty() bool {
+        return len(set) == 0
+}
+
+// Add - adds string to the set.
+func (set StringSet) Add(s string) {
+        set[s] = struct{}{}
+}
+
+// Remove - removes string in the set.  It does nothing if string does not exist in the set.
+func (set StringSet) Remove(s string) {
+        delete(set, s)
+}
+
+// Contains - checks if string is in the set.
+func (set StringSet) Contains(s string) bool {
+        _, ok := set[s]
+        return ok
+}
+
+// FuncMatch - returns new set containing each value who passes match function.
+// A 'matchFn' should accept element in a set as first argument and
+// 'matchString' as second argument.  The function can do any logic to
+// compare both the arguments and should return true to accept element in
+// a set to include in output set else the element is ignored.
+func (set StringSet) FuncMatch(matchFn func(string, string) bool, matchString string) StringSet {
+        nset := NewStringSet()
+        for k := range set {
+                if matchFn(k, matchString) {
+                        nset.Add(k)
+                }
+        }
+        return nset
+}
+
+// ApplyFunc - returns new set containing each value processed by 'applyFn'.
+// A 'applyFn' should accept element in a set as a argument and return
+// a processed string.  The function can do any logic to return a processed
+// string.
+func (set StringSet) ApplyFunc(applyFn func(string) string) StringSet {
+        nset := NewStringSet()
+        for k := range set {
+                nset.Add(applyFn(k))
+        }
+        return nset
+}
+
+// Equals - checks whether given set is equal to current set or not.
+func (set StringSet) Equals(sset StringSet) bool {
+        // If length of set is not equal to length of given set, the
+        // set is not equal to given set.
+        if len(set) != len(sset) {
+                return false
+        }
+
+        // As both sets are equal in length, check each elements are equal.
+        for k := range set {
+                if _, ok := sset[k]; !ok {
+                        return false
+                }
+        }
+
+        return true
+}
+
+// Intersection - returns the intersection with given set as new set.
+func (set StringSet) Intersection(sset StringSet) StringSet {
+        nset := NewStringSet()
+        for k := range set {
+                if _, ok := sset[k]; ok {
+                        nset.Add(k)
+                }
+        }
+
+        return nset
+}
+
+// Difference - returns the difference with given set as new set.
+func (set StringSet) Difference(sset StringSet) StringSet {
+        nset := NewStringSet()
+        for k := range set {
+                if _, ok := sset[k]; !ok {
+                        nset.Add(k)
+                }
+        }
+
+        return nset
+}
+
+// Union - returns the union with given set as new set.
+func (set StringSet) Union(sset StringSet) StringSet {
+        nset := NewStringSet()
+        for k := range set {
+                nset.Add(k)
+        }
+
+        for k := range sset {
+                nset.Add(k)
+        }
+
+        return nset
+}
+
+// MarshalJSON - converts to JSON data.
+func (set StringSet) MarshalJSON() ([]byte, error) {
+        return json.Marshal(set.ToSlice())
+}
+
+// UnmarshalJSON - parses JSON data and creates new set with it.
+// If 'data' contains JSON string array, the set contains each string.
+// If 'data' contains JSON string, the set contains the string as one element.
+// If 'data' contains Other JSON types, JSON parse error is returned.
+func (set *StringSet) UnmarshalJSON(data []byte) error {
+        sl := []string{}
+        var err error
+        if err = json.Unmarshal(data, &sl); err == nil {
+                *set = make(StringSet)
+                for _, s := range sl {
+                        set.Add(s)
+                }
+        } else {
+                var s string
+                if err = json.Unmarshal(data, &s); err == nil {
+                        *set = make(StringSet)
+                        set.Add(s)
+                }
+        }
+
+        return err
+}
+
+// String - returns printable string of the set.
+func (set StringSet) String() string {
+        return fmt.Sprintf("%s", set.ToSlice())
+}
+
+// NewStringSet - creates new string set.
+func NewStringSet() StringSet {
+        return make(StringSet)
+}
+
+// CreateStringSet - creates new string set with given string values.
+func CreateStringSet(sl ...string) StringSet {
+        set := make(StringSet)
+        for _, k := range sl {
+                set.Add(k)
+        }
+        return set
+}
+
+// CopyStringSet - returns copy of given set.
+func CopyStringSet(set StringSet) StringSet {
+        nset := NewStringSet()
+        for k, v := range set {
+                nset[k] = v
+        }
+        return nset
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-streaming-unsigned-trailer.go b/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-streaming-unsigned-trailer.go
new file mode 100644
index 0000000..77540e2
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-streaming-unsigned-trailer.go
@@ -0,0 +1,224 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2022 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 signer
+
+import (
+        "bytes"
+        "fmt"
+        "io"
+        "net/http"
+        "strconv"
+        "strings"
+        "time"
+)
+
+// getUnsignedChunkLength - calculates the length of chunk metadata
+func getUnsignedChunkLength(chunkDataSize int64) int64 {
+        return int64(len(fmt.Sprintf("%x", chunkDataSize))) +
+                crlfLen +
+                chunkDataSize +
+                crlfLen
+}
+
+// getUSStreamLength - calculates the length of the overall stream (data + metadata)
+func getUSStreamLength(dataLen, chunkSize int64, trailers http.Header) int64 {
+        if dataLen <= 0 {
+                return 0
+        }
+
+        chunksCount := int64(dataLen / chunkSize)
+        remainingBytes := int64(dataLen % chunkSize)
+        streamLen := int64(0)
+        streamLen += chunksCount * getUnsignedChunkLength(chunkSize)
+        if remainingBytes > 0 {
+                streamLen += getUnsignedChunkLength(remainingBytes)
+        }
+        streamLen += getUnsignedChunkLength(0)
+        if len(trailers) > 0 {
+                for name, placeholder := range trailers {
+                        if len(placeholder) > 0 {
+                                streamLen += int64(len(name) + len(trailerKVSeparator) + len(placeholder[0]) + 1)
+                        }
+                }
+                streamLen += crlfLen
+        }
+
+        return streamLen
+}
+
+// prepareStreamingRequest - prepares a request with appropriate
+// headers before computing the seed signature.
+func prepareUSStreamingRequest(req *http.Request, sessionToken string, dataLen int64, timestamp time.Time) {
+        req.TransferEncoding = []string{"aws-chunked"}
+        if sessionToken != "" {
+                req.Header.Set("X-Amz-Security-Token", sessionToken)
+        }
+
+        req.Header.Set("X-Amz-Date", timestamp.Format(iso8601DateFormat))
+        // Set content length with streaming signature for each chunk included.
+        req.ContentLength = getUSStreamLength(dataLen, int64(payloadChunkSize), req.Trailer)
+}
+
+// StreamingUSReader implements chunked upload signature as a reader on
+// top of req.Body's ReaderCloser chunk header;data;... repeat
+type StreamingUSReader struct {
+        contentLen     int64         // Content-Length from req header
+        baseReadCloser io.ReadCloser // underlying io.Reader
+        bytesRead      int64         // bytes read from underlying io.Reader
+        buf            bytes.Buffer  // holds signed chunk
+        chunkBuf       []byte        // holds raw data read from req Body
+        chunkBufLen    int           // no. of bytes read so far into chunkBuf
+        done           bool          // done reading the underlying reader to EOF
+        chunkNum       int
+        totalChunks    int
+        lastChunkSize  int
+        trailer        http.Header
+}
+
+// writeChunk - signs a chunk read from s.baseReader of chunkLen size.
+func (s *StreamingUSReader) writeChunk(chunkLen int, addCrLf bool) {
+        s.buf.WriteString(strconv.FormatInt(int64(chunkLen), 16) + "\r\n")
+
+        // Write chunk data into streaming buffer
+        s.buf.Write(s.chunkBuf[:chunkLen])
+
+        // Write the chunk trailer.
+        if addCrLf {
+                s.buf.Write([]byte("\r\n"))
+        }
+
+        // Reset chunkBufLen for next chunk read.
+        s.chunkBufLen = 0
+        s.chunkNum++
+}
+
+// addSignedTrailer - adds a trailer with the provided headers,
+// then signs a chunk and adds it to output.
+func (s *StreamingUSReader) addTrailer(h http.Header) {
+        olen := len(s.chunkBuf)
+        s.chunkBuf = s.chunkBuf[:0]
+        for k, v := range h {
+                s.chunkBuf = append(s.chunkBuf, []byte(strings.ToLower(k)+trailerKVSeparator+v[0]+"\n")...)
+        }
+
+        s.buf.Write(s.chunkBuf)
+        s.buf.WriteString("\r\n\r\n")
+
+        // Reset chunkBufLen for next chunk read.
+        s.chunkBuf = s.chunkBuf[:olen]
+        s.chunkBufLen = 0
+        s.chunkNum++
+}
+
+// StreamingUnsignedV4 - provides chunked upload
+func StreamingUnsignedV4(req *http.Request, sessionToken string, dataLen int64, reqTime time.Time) *http.Request {
+        // Set headers needed for streaming signature.
+        prepareUSStreamingRequest(req, sessionToken, dataLen, reqTime)
+
+        if req.Body == nil {
+                req.Body = io.NopCloser(bytes.NewReader([]byte("")))
+        }
+
+        stReader := &StreamingUSReader{
+                baseReadCloser: req.Body,
+                chunkBuf:       make([]byte, payloadChunkSize),
+                contentLen:     dataLen,
+                chunkNum:       1,
+                totalChunks:    int((dataLen+payloadChunkSize-1)/payloadChunkSize) + 1,
+                lastChunkSize:  int(dataLen % payloadChunkSize),
+        }
+        if len(req.Trailer) > 0 {
+                stReader.trailer = req.Trailer
+                // Remove...
+                req.Trailer = nil
+        }
+
+        req.Body = stReader
+
+        return req
+}
+
+// Read - this method performs chunk upload signature providing a
+// io.Reader interface.
+func (s *StreamingUSReader) Read(buf []byte) (int, error) {
+        switch {
+        // After the last chunk is read from underlying reader, we
+        // never re-fill s.buf.
+        case s.done:
+
+        // s.buf will be (re-)filled with next chunk when has lesser
+        // bytes than asked for.
+        case s.buf.Len() < len(buf):
+                s.chunkBufLen = 0
+                for {
+                        n1, err := s.baseReadCloser.Read(s.chunkBuf[s.chunkBufLen:])
+                        // Usually we validate `err` first, but in this case
+                        // we are validating n > 0 for the following reasons.
+                        //
+                        // 1. n > 0, err is one of io.EOF, nil (near end of stream)
+                        // A Reader returning a non-zero number of bytes at the end
+                        // of the input stream may return either err == EOF or err == nil
+                        //
+                        // 2. n == 0, err is io.EOF (actual end of stream)
+                        //
+                        // Callers should always process the n > 0 bytes returned
+                        // before considering the error err.
+                        if n1 > 0 {
+                                s.chunkBufLen += n1
+                                s.bytesRead += int64(n1)
+
+                                if s.chunkBufLen == payloadChunkSize ||
+                                        (s.chunkNum == s.totalChunks-1 &&
+                                                s.chunkBufLen == s.lastChunkSize) {
+                                        // Sign the chunk and write it to s.buf.
+                                        s.writeChunk(s.chunkBufLen, true)
+                                        break
+                                }
+                        }
+                        if err != nil {
+                                if err == io.EOF {
+                                        // No more data left in baseReader - last chunk.
+                                        // Done reading the last chunk from baseReader.
+                                        s.done = true
+
+                                        // bytes read from baseReader different than
+                                        // content length provided.
+                                        if s.bytesRead != s.contentLen {
+                                                return 0, fmt.Errorf("http: ContentLength=%d with Body length %d", s.contentLen, s.bytesRead)
+                                        }
+
+                                        // Sign the chunk and write it to s.buf.
+                                        s.writeChunk(0, len(s.trailer) == 0)
+                                        if len(s.trailer) > 0 {
+                                                // Trailer must be set now.
+                                                s.addTrailer(s.trailer)
+                                        }
+                                        break
+                                }
+                                return 0, err
+                        }
+
+                }
+        }
+        return s.buf.Read(buf)
+}
+
+// Close - this method makes underlying io.ReadCloser's Close method available.
+func (s *StreamingUSReader) Close() error {
+        return s.baseReadCloser.Close()
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-streaming.go b/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-streaming.go
new file mode 100644
index 0000000..1c2f1dc
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-streaming.go
@@ -0,0 +1,403 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 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 signer
+
+import (
+        "bytes"
+        "encoding/hex"
+        "fmt"
+        "io"
+        "net/http"
+        "strconv"
+        "strings"
+        "time"
+
+        md5simd "github.com/minio/md5-simd"
+)
+
+// Reference for constants used below -
+// http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-streaming.html#example-signature-calculations-streaming
+const (
+        streamingSignAlgorithm        = "STREAMING-AWS4-HMAC-SHA256-PAYLOAD"
+        streamingSignTrailerAlgorithm = "STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER"
+        streamingPayloadHdr           = "AWS4-HMAC-SHA256-PAYLOAD"
+        streamingTrailerHdr           = "AWS4-HMAC-SHA256-TRAILER"
+        emptySHA256                   = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+        payloadChunkSize              = 64 * 1024
+        chunkSigConstLen              = 17 // ";chunk-signature="
+        signatureStrLen               = 64 // e.g. "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2"
+        crlfLen                       = 2  // CRLF
+        trailerKVSeparator            = ":"
+        trailerSignature              = "x-amz-trailer-signature"
+)
+
+// Request headers to be ignored while calculating seed signature for
+// a request.
+var ignoredStreamingHeaders = map[string]bool{
+        "Authorization": true,
+        "User-Agent":    true,
+        "Content-Type":  true,
+}
+
+// getSignedChunkLength - calculates the length of chunk metadata
+func getSignedChunkLength(chunkDataSize int64) int64 {
+        return int64(len(fmt.Sprintf("%x", chunkDataSize))) +
+                chunkSigConstLen +
+                signatureStrLen +
+                crlfLen +
+                chunkDataSize +
+                crlfLen
+}
+
+// getStreamLength - calculates the length of the overall stream (data + metadata)
+func getStreamLength(dataLen, chunkSize int64, trailers http.Header) int64 {
+        if dataLen <= 0 {
+                return 0
+        }
+
+        chunksCount := int64(dataLen / chunkSize)
+        remainingBytes := int64(dataLen % chunkSize)
+        streamLen := int64(0)
+        streamLen += chunksCount * getSignedChunkLength(chunkSize)
+        if remainingBytes > 0 {
+                streamLen += getSignedChunkLength(remainingBytes)
+        }
+        streamLen += getSignedChunkLength(0)
+        if len(trailers) > 0 {
+                for name, placeholder := range trailers {
+                        if len(placeholder) > 0 {
+                                streamLen += int64(len(name) + len(trailerKVSeparator) + len(placeholder[0]) + 1)
+                        }
+                }
+                streamLen += int64(len(trailerSignature)+len(trailerKVSeparator)) + signatureStrLen + crlfLen + crlfLen
+        }
+
+        return streamLen
+}
+
+// buildChunkStringToSign - returns the string to sign given chunk data
+// and previous signature.
+func buildChunkStringToSign(t time.Time, region, previousSig, chunkChecksum string) string {
+        stringToSignParts := []string{
+                streamingPayloadHdr,
+                t.Format(iso8601DateFormat),
+                getScope(region, t, ServiceTypeS3),
+                previousSig,
+                emptySHA256,
+                chunkChecksum,
+        }
+
+        return strings.Join(stringToSignParts, "\n")
+}
+
+// buildTrailerChunkStringToSign - returns the string to sign given chunk data
+// and previous signature.
+func buildTrailerChunkStringToSign(t time.Time, region, previousSig, chunkChecksum string) string {
+        stringToSignParts := []string{
+                streamingTrailerHdr,
+                t.Format(iso8601DateFormat),
+                getScope(region, t, ServiceTypeS3),
+                previousSig,
+                chunkChecksum,
+        }
+
+        return strings.Join(stringToSignParts, "\n")
+}
+
+// prepareStreamingRequest - prepares a request with appropriate
+// headers before computing the seed signature.
+func prepareStreamingRequest(req *http.Request, sessionToken string, dataLen int64, timestamp time.Time) {
+        // Set x-amz-content-sha256 header.
+        if len(req.Trailer) == 0 {
+                req.Header.Set("X-Amz-Content-Sha256", streamingSignAlgorithm)
+        } else {
+                req.Header.Set("X-Amz-Content-Sha256", streamingSignTrailerAlgorithm)
+                for k := range req.Trailer {
+                        req.Header.Add("X-Amz-Trailer", strings.ToLower(k))
+                }
+                req.TransferEncoding = []string{"aws-chunked"}
+        }
+
+        if sessionToken != "" {
+                req.Header.Set("X-Amz-Security-Token", sessionToken)
+        }
+
+        req.Header.Set("X-Amz-Date", timestamp.Format(iso8601DateFormat))
+        // Set content length with streaming signature for each chunk included.
+        req.ContentLength = getStreamLength(dataLen, int64(payloadChunkSize), req.Trailer)
+        req.Header.Set("x-amz-decoded-content-length", strconv.FormatInt(dataLen, 10))
+}
+
+// buildChunkHeader - returns the chunk header.
+// e.g string(IntHexBase(chunk-size)) + ";chunk-signature=" + signature + \r\n + chunk-data + \r\n
+func buildChunkHeader(chunkLen int64, signature string) []byte {
+        return []byte(strconv.FormatInt(chunkLen, 16) + ";chunk-signature=" + signature + "\r\n")
+}
+
+// buildChunkSignature - returns chunk signature for a given chunk and previous signature.
+func buildChunkSignature(chunkCheckSum string, reqTime time.Time, region,
+        previousSignature, secretAccessKey string,
+) string {
+        chunkStringToSign := buildChunkStringToSign(reqTime, region,
+                previousSignature, chunkCheckSum)
+        signingKey := getSigningKey(secretAccessKey, region, reqTime, ServiceTypeS3)
+        return getSignature(signingKey, chunkStringToSign)
+}
+
+// buildChunkSignature - returns chunk signature for a given chunk and previous signature.
+func buildTrailerChunkSignature(chunkChecksum string, reqTime time.Time, region,
+        previousSignature, secretAccessKey string,
+) string {
+        chunkStringToSign := buildTrailerChunkStringToSign(reqTime, region,
+                previousSignature, chunkChecksum)
+        signingKey := getSigningKey(secretAccessKey, region, reqTime, ServiceTypeS3)
+        return getSignature(signingKey, chunkStringToSign)
+}
+
+// getSeedSignature - returns the seed signature for a given request.
+func (s *StreamingReader) setSeedSignature(req *http.Request) {
+        // Get canonical request
+        canonicalRequest := getCanonicalRequest(*req, ignoredStreamingHeaders, getHashedPayload(*req))
+
+        // Get string to sign from canonical request.
+        stringToSign := getStringToSignV4(s.reqTime, s.region, canonicalRequest, ServiceTypeS3)
+
+        signingKey := getSigningKey(s.secretAccessKey, s.region, s.reqTime, ServiceTypeS3)
+
+        // Calculate signature.
+        s.seedSignature = getSignature(signingKey, stringToSign)
+}
+
+// StreamingReader implements chunked upload signature as a reader on
+// top of req.Body's ReaderCloser chunk header;data;... repeat
+type StreamingReader struct {
+        accessKeyID     string
+        secretAccessKey string
+        sessionToken    string
+        region          string
+        prevSignature   string
+        seedSignature   string
+        contentLen      int64         // Content-Length from req header
+        baseReadCloser  io.ReadCloser // underlying io.Reader
+        bytesRead       int64         // bytes read from underlying io.Reader
+        buf             bytes.Buffer  // holds signed chunk
+        chunkBuf        []byte        // holds raw data read from req Body
+        chunkBufLen     int           // no. of bytes read so far into chunkBuf
+        done            bool          // done reading the underlying reader to EOF
+        reqTime         time.Time
+        chunkNum        int
+        totalChunks     int
+        lastChunkSize   int
+        trailer         http.Header
+        sh256           md5simd.Hasher
+}
+
+// signChunk - signs a chunk read from s.baseReader of chunkLen size.
+func (s *StreamingReader) signChunk(chunkLen int, addCrLf bool) {
+        // Compute chunk signature for next header
+        s.sh256.Reset()
+        s.sh256.Write(s.chunkBuf[:chunkLen])
+        chunckChecksum := hex.EncodeToString(s.sh256.Sum(nil))
+
+        signature := buildChunkSignature(chunckChecksum, s.reqTime,
+                s.region, s.prevSignature, s.secretAccessKey)
+
+        // For next chunk signature computation
+        s.prevSignature = signature
+
+        // Write chunk header into streaming buffer
+        chunkHdr := buildChunkHeader(int64(chunkLen), signature)
+        s.buf.Write(chunkHdr)
+
+        // Write chunk data into streaming buffer
+        s.buf.Write(s.chunkBuf[:chunkLen])
+
+        // Write the chunk trailer.
+        if addCrLf {
+                s.buf.Write([]byte("\r\n"))
+        }
+
+        // Reset chunkBufLen for next chunk read.
+        s.chunkBufLen = 0
+        s.chunkNum++
+}
+
+// addSignedTrailer - adds a trailer with the provided headers,
+// then signs a chunk and adds it to output.
+func (s *StreamingReader) addSignedTrailer(h http.Header) {
+        olen := len(s.chunkBuf)
+        s.chunkBuf = s.chunkBuf[:0]
+        for k, v := range h {
+                s.chunkBuf = append(s.chunkBuf, []byte(strings.ToLower(k)+trailerKVSeparator+v[0]+"\n")...)
+        }
+
+        s.sh256.Reset()
+        s.sh256.Write(s.chunkBuf)
+        chunkChecksum := hex.EncodeToString(s.sh256.Sum(nil))
+        // Compute chunk signature
+        signature := buildTrailerChunkSignature(chunkChecksum, s.reqTime,
+                s.region, s.prevSignature, s.secretAccessKey)
+
+        // For next chunk signature computation
+        s.prevSignature = signature
+
+        s.buf.Write(s.chunkBuf)
+        s.buf.WriteString("\r\n" + trailerSignature + trailerKVSeparator + signature + "\r\n\r\n")
+
+        // Reset chunkBufLen for next chunk read.
+        s.chunkBuf = s.chunkBuf[:olen]
+        s.chunkBufLen = 0
+        s.chunkNum++
+}
+
+// setStreamingAuthHeader - builds and sets authorization header value
+// for streaming signature.
+func (s *StreamingReader) setStreamingAuthHeader(req *http.Request) {
+        credential := GetCredential(s.accessKeyID, s.region, s.reqTime, ServiceTypeS3)
+        authParts := []string{
+                signV4Algorithm + " Credential=" + credential,
+                "SignedHeaders=" + getSignedHeaders(*req, ignoredStreamingHeaders),
+                "Signature=" + s.seedSignature,
+        }
+
+        // Set authorization header.
+        auth := strings.Join(authParts, ",")
+        req.Header.Set("Authorization", auth)
+}
+
+// StreamingSignV4 - provides chunked upload signatureV4 support by
+// implementing io.Reader.
+func StreamingSignV4(req *http.Request, accessKeyID, secretAccessKey, sessionToken,
+        region string, dataLen int64, reqTime time.Time, sh256 md5simd.Hasher,
+) *http.Request {
+        // Set headers needed for streaming signature.
+        prepareStreamingRequest(req, sessionToken, dataLen, reqTime)
+
+        if req.Body == nil {
+                req.Body = io.NopCloser(bytes.NewReader([]byte("")))
+        }
+
+        stReader := &StreamingReader{
+                baseReadCloser:  req.Body,
+                accessKeyID:     accessKeyID,
+                secretAccessKey: secretAccessKey,
+                sessionToken:    sessionToken,
+                region:          region,
+                reqTime:         reqTime,
+                chunkBuf:        make([]byte, payloadChunkSize),
+                contentLen:      dataLen,
+                chunkNum:        1,
+                totalChunks:     int((dataLen+payloadChunkSize-1)/payloadChunkSize) + 1,
+                lastChunkSize:   int(dataLen % payloadChunkSize),
+                sh256:           sh256,
+        }
+        if len(req.Trailer) > 0 {
+                stReader.trailer = req.Trailer
+                // Remove...
+                req.Trailer = nil
+        }
+
+        // Add the request headers required for chunk upload signing.
+
+        // Compute the seed signature.
+        stReader.setSeedSignature(req)
+
+        // Set the authorization header with the seed signature.
+        stReader.setStreamingAuthHeader(req)
+
+        // Set seed signature as prevSignature for subsequent
+        // streaming signing process.
+        stReader.prevSignature = stReader.seedSignature
+        req.Body = stReader
+
+        return req
+}
+
+// Read - this method performs chunk upload signature providing a
+// io.Reader interface.
+func (s *StreamingReader) Read(buf []byte) (int, error) {
+        switch {
+        // After the last chunk is read from underlying reader, we
+        // never re-fill s.buf.
+        case s.done:
+
+        // s.buf will be (re-)filled with next chunk when has lesser
+        // bytes than asked for.
+        case s.buf.Len() < len(buf):
+                s.chunkBufLen = 0
+                for {
+                        n1, err := s.baseReadCloser.Read(s.chunkBuf[s.chunkBufLen:])
+                        // Usually we validate `err` first, but in this case
+                        // we are validating n > 0 for the following reasons.
+                        //
+                        // 1. n > 0, err is one of io.EOF, nil (near end of stream)
+                        // A Reader returning a non-zero number of bytes at the end
+                        // of the input stream may return either err == EOF or err == nil
+                        //
+                        // 2. n == 0, err is io.EOF (actual end of stream)
+                        //
+                        // Callers should always process the n > 0 bytes returned
+                        // before considering the error err.
+                        if n1 > 0 {
+                                s.chunkBufLen += n1
+                                s.bytesRead += int64(n1)
+
+                                if s.chunkBufLen == payloadChunkSize ||
+                                        (s.chunkNum == s.totalChunks-1 &&
+                                                s.chunkBufLen == s.lastChunkSize) {
+                                        // Sign the chunk and write it to s.buf.
+                                        s.signChunk(s.chunkBufLen, true)
+                                        break
+                                }
+                        }
+                        if err != nil {
+                                if err == io.EOF {
+                                        // No more data left in baseReader - last chunk.
+                                        // Done reading the last chunk from baseReader.
+                                        s.done = true
+
+                                        // bytes read from baseReader different than
+                                        // content length provided.
+                                        if s.bytesRead != s.contentLen {
+                                                return 0, fmt.Errorf("http: ContentLength=%d with Body length %d", s.contentLen, s.bytesRead)
+                                        }
+
+                                        // Sign the chunk and write it to s.buf.
+                                        s.signChunk(0, len(s.trailer) == 0)
+                                        if len(s.trailer) > 0 {
+                                                // Trailer must be set now.
+                                                s.addSignedTrailer(s.trailer)
+                                        }
+                                        break
+                                }
+                                return 0, err
+                        }
+
+                }
+        }
+        return s.buf.Read(buf)
+}
+
+// Close - this method makes underlying io.ReadCloser's Close method available.
+func (s *StreamingReader) Close() error {
+        if s.sh256 != nil {
+                s.sh256.Close()
+                s.sh256 = nil
+        }
+        return s.baseReadCloser.Close()
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-v2.go b/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-v2.go
new file mode 100644
index 0000000..fa4f8c9
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-v2.go
@@ -0,0 +1,319 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 signer
+
+import (
+        "bytes"
+        "crypto/hmac"
+        "crypto/sha1"
+        "encoding/base64"
+        "fmt"
+        "net/http"
+        "net/url"
+        "sort"
+        "strconv"
+        "strings"
+        "time"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// Signature and API related constants.
+const (
+        signV2Algorithm = "AWS"
+)
+
+// Encode input URL path to URL encoded path.
+func encodeURL2Path(req *http.Request, virtualHost bool) (path string) {
+        if virtualHost {
+                reqHost := getHostAddr(req)
+                dotPos := strings.Index(reqHost, ".")
+                if dotPos > -1 {
+                        bucketName := reqHost[:dotPos]
+                        path = "/" + bucketName
+                        path += req.URL.Path
+                        path = s3utils.EncodePath(path)
+                        return
+                }
+        }
+        path = s3utils.EncodePath(req.URL.Path)
+        return
+}
+
+// PreSignV2 - presign the request in following style.
+// https://${S3_BUCKET}.s3.amazonaws.com/${S3_OBJECT}?AWSAccessKeyId=${S3_ACCESS_KEY}&Expires=${TIMESTAMP}&Signature=${SIGNATURE}.
+func PreSignV2(req http.Request, accessKeyID, secretAccessKey string, expires int64, virtualHost bool) *http.Request {
+        // Presign is not needed for anonymous credentials.
+        if accessKeyID == "" || secretAccessKey == "" {
+                return &req
+        }
+
+        d := time.Now().UTC()
+        // Find epoch expires when the request will expire.
+        epochExpires := d.Unix() + expires
+
+        // Add expires header if not present.
+        if expiresStr := req.Header.Get("Expires"); expiresStr == "" {
+                req.Header.Set("Expires", strconv.FormatInt(epochExpires, 10))
+        }
+
+        // Get presigned string to sign.
+        stringToSign := preStringToSignV2(req, virtualHost)
+        hm := hmac.New(sha1.New, []byte(secretAccessKey))
+        hm.Write([]byte(stringToSign))
+
+        // Calculate signature.
+        signature := base64.StdEncoding.EncodeToString(hm.Sum(nil))
+
+        query := req.URL.Query()
+        // Handle specially for Google Cloud Storage.
+        if strings.Contains(getHostAddr(&req), ".storage.googleapis.com") {
+                query.Set("GoogleAccessId", accessKeyID)
+        } else {
+                query.Set("AWSAccessKeyId", accessKeyID)
+        }
+
+        // Fill in Expires for presigned query.
+        query.Set("Expires", strconv.FormatInt(epochExpires, 10))
+
+        // Encode query and save.
+        req.URL.RawQuery = s3utils.QueryEncode(query)
+
+        // Save signature finally.
+        req.URL.RawQuery += "&Signature=" + s3utils.EncodePath(signature)
+
+        // Return.
+        return &req
+}
+
+// PostPresignSignatureV2 - presigned signature for PostPolicy
+// request.
+func PostPresignSignatureV2(policyBase64, secretAccessKey string) string {
+        hm := hmac.New(sha1.New, []byte(secretAccessKey))
+        hm.Write([]byte(policyBase64))
+        signature := base64.StdEncoding.EncodeToString(hm.Sum(nil))
+        return signature
+}
+
+// Authorization = "AWS" + " " + AWSAccessKeyId + ":" + Signature;
+// Signature = Base64( HMAC-SHA1( YourSecretAccessKeyID, UTF-8-Encoding-Of( StringToSign ) ) );
+//
+// StringToSign = HTTP-Verb + "\n" +
+//      Content-Md5 + "\n" +
+//      Content-Type + "\n" +
+//      Date + "\n" +
+//      CanonicalizedProtocolHeaders +
+//      CanonicalizedResource;
+//
+// CanonicalizedResource = [ "/" + Bucket ] +
+//      <HTTP-Request-URI, from the protocol name up to the query string> +
+//      [ subresource, if present. For example "?acl", "?location", "?logging", or "?torrent"];
+//
+// CanonicalizedProtocolHeaders = <described below>
+
+// SignV2 sign the request before Do() (AWS Signature Version 2).
+func SignV2(req http.Request, accessKeyID, secretAccessKey string, virtualHost bool) *http.Request {
+        // Signature calculation is not needed for anonymous credentials.
+        if accessKeyID == "" || secretAccessKey == "" {
+                return &req
+        }
+
+        // Initial time.
+        d := time.Now().UTC()
+
+        // Add date if not present.
+        if date := req.Header.Get("Date"); date == "" {
+                req.Header.Set("Date", d.Format(http.TimeFormat))
+        }
+
+        // Calculate HMAC for secretAccessKey.
+        stringToSign := stringToSignV2(req, virtualHost)
+        hm := hmac.New(sha1.New, []byte(secretAccessKey))
+        hm.Write([]byte(stringToSign))
+
+        // Prepare auth header.
+        authHeader := new(bytes.Buffer)
+        authHeader.WriteString(fmt.Sprintf("%s %s:", signV2Algorithm, accessKeyID))
+        encoder := base64.NewEncoder(base64.StdEncoding, authHeader)
+        encoder.Write(hm.Sum(nil))
+        encoder.Close()
+
+        // Set Authorization header.
+        req.Header.Set("Authorization", authHeader.String())
+
+        return &req
+}
+
+// From the Amazon docs:
+//
+// StringToSign = HTTP-Verb + "\n" +
+//
+//      Content-Md5 + "\n" +
+//      Content-Type + "\n" +
+//      Expires + "\n" +
+//      CanonicalizedProtocolHeaders +
+//      CanonicalizedResource;
+func preStringToSignV2(req http.Request, virtualHost bool) string {
+        buf := new(bytes.Buffer)
+        // Write standard headers.
+        writePreSignV2Headers(buf, req)
+        // Write canonicalized protocol headers if any.
+        writeCanonicalizedHeaders(buf, req)
+        // Write canonicalized Query resources if any.
+        writeCanonicalizedResource(buf, req, virtualHost)
+        return buf.String()
+}
+
+// writePreSignV2Headers - write preSign v2 required headers.
+func writePreSignV2Headers(buf *bytes.Buffer, req http.Request) {
+        buf.WriteString(req.Method + "\n")
+        buf.WriteString(req.Header.Get("Content-Md5") + "\n")
+        buf.WriteString(req.Header.Get("Content-Type") + "\n")
+        buf.WriteString(req.Header.Get("Expires") + "\n")
+}
+
+// From the Amazon docs:
+//
+// StringToSign = HTTP-Verb + "\n" +
+//
+//      Content-Md5 + "\n" +
+//      Content-Type + "\n" +
+//      Date + "\n" +
+//      CanonicalizedProtocolHeaders +
+//      CanonicalizedResource;
+func stringToSignV2(req http.Request, virtualHost bool) string {
+        buf := new(bytes.Buffer)
+        // Write standard headers.
+        writeSignV2Headers(buf, req)
+        // Write canonicalized protocol headers if any.
+        writeCanonicalizedHeaders(buf, req)
+        // Write canonicalized Query resources if any.
+        writeCanonicalizedResource(buf, req, virtualHost)
+        return buf.String()
+}
+
+// writeSignV2Headers - write signV2 required headers.
+func writeSignV2Headers(buf *bytes.Buffer, req http.Request) {
+        buf.WriteString(req.Method + "\n")
+        buf.WriteString(req.Header.Get("Content-Md5") + "\n")
+        buf.WriteString(req.Header.Get("Content-Type") + "\n")
+        buf.WriteString(req.Header.Get("Date") + "\n")
+}
+
+// writeCanonicalizedHeaders - write canonicalized headers.
+func writeCanonicalizedHeaders(buf *bytes.Buffer, req http.Request) {
+        var protoHeaders []string
+        vals := make(map[string][]string)
+        for k, vv := range req.Header {
+                // All the AMZ headers should be lowercase
+                lk := strings.ToLower(k)
+                if strings.HasPrefix(lk, "x-amz") {
+                        protoHeaders = append(protoHeaders, lk)
+                        vals[lk] = vv
+                }
+        }
+        sort.Strings(protoHeaders)
+        for _, k := range protoHeaders {
+                buf.WriteString(k)
+                buf.WriteByte(':')
+                for idx, v := range vals[k] {
+                        if idx > 0 {
+                                buf.WriteByte(',')
+                        }
+                        buf.WriteString(v)
+                }
+                buf.WriteByte('\n')
+        }
+}
+
+// AWS S3 Signature V2 calculation rule is give here:
+// http://docs.aws.amazon.com/AmazonS3/latest/dev/RESTAuthentication.html#RESTAuthenticationStringToSign
+
+// Whitelist resource list that will be used in query string for signature-V2 calculation.
+//
+// This list should be kept alphabetically sorted, do not hastily edit.
+var resourceList = []string{
+        "acl",
+        "cors",
+        "delete",
+        "encryption",
+        "legal-hold",
+        "lifecycle",
+        "location",
+        "logging",
+        "notification",
+        "partNumber",
+        "policy",
+        "replication",
+        "requestPayment",
+        "response-cache-control",
+        "response-content-disposition",
+        "response-content-encoding",
+        "response-content-language",
+        "response-content-type",
+        "response-expires",
+        "retention",
+        "select",
+        "select-type",
+        "tagging",
+        "torrent",
+        "uploadId",
+        "uploads",
+        "versionId",
+        "versioning",
+        "versions",
+        "website",
+}
+
+// From the Amazon docs:
+//
+// CanonicalizedResource = [ "/" + Bucket ] +
+//
+//      <HTTP-Request-URI, from the protocol name up to the query string> +
+//      [ sub-resource, if present. For example "?acl", "?location", "?logging", or "?torrent"];
+func writeCanonicalizedResource(buf *bytes.Buffer, req http.Request, virtualHost bool) {
+        // Save request URL.
+        requestURL := req.URL
+        // Get encoded URL path.
+        buf.WriteString(encodeURL2Path(&req, virtualHost))
+        if requestURL.RawQuery != "" {
+                var n int
+                vals, _ := url.ParseQuery(requestURL.RawQuery)
+                // Verify if any sub resource queries are present, if yes
+                // canonicallize them.
+                for _, resource := range resourceList {
+                        if vv, ok := vals[resource]; ok && len(vv) > 0 {
+                                n++
+                                // First element
+                                switch n {
+                                case 1:
+                                        buf.WriteByte('?')
+                                // The rest
+                                default:
+                                        buf.WriteByte('&')
+                                }
+                                buf.WriteString(resource)
+                                // Request parameters
+                                if len(vv[0]) > 0 {
+                                        buf.WriteByte('=')
+                                        buf.WriteString(vv[0])
+                                }
+                        }
+                }
+        }
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-v4.go b/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-v4.go
new file mode 100644
index 0000000..ffd2514
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/signer/request-signature-v4.go
@@ -0,0 +1,351 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 signer
+
+import (
+        "bytes"
+        "encoding/hex"
+        "net/http"
+        "sort"
+        "strconv"
+        "strings"
+        "time"
+
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+)
+
+// Signature and API related constants.
+const (
+        signV4Algorithm   = "AWS4-HMAC-SHA256"
+        iso8601DateFormat = "20060102T150405Z"
+        yyyymmdd          = "20060102"
+)
+
+// Different service types
+const (
+        ServiceTypeS3  = "s3"
+        ServiceTypeSTS = "sts"
+)
+
+// Excerpts from @lsegal -
+// https:/github.com/aws/aws-sdk-js/issues/659#issuecomment-120477258.
+//
+// * User-Agent
+// This is ignored from signing because signing this causes problems with generating pre-signed
+// URLs (that are executed by other agents) or when customers pass requests through proxies, which
+// may modify the user-agent.
+//
+// * Authorization
+// Is skipped for obvious reasons.
+//
+// * Accept-Encoding
+// Some S3 servers like Hitachi Content Platform do not honor this header for signature
+// calculation.
+var v4IgnoredHeaders = map[string]bool{
+        "Accept-Encoding": true,
+        "Authorization":   true,
+        "User-Agent":      true,
+}
+
+// getSigningKey hmac seed to calculate final signature.
+func getSigningKey(secret, loc string, t time.Time, serviceType string) []byte {
+        date := sumHMAC([]byte("AWS4"+secret), []byte(t.Format(yyyymmdd)))
+        location := sumHMAC(date, []byte(loc))
+        service := sumHMAC(location, []byte(serviceType))
+        signingKey := sumHMAC(service, []byte("aws4_request"))
+        return signingKey
+}
+
+// getSignature final signature in hexadecimal form.
+func getSignature(signingKey []byte, stringToSign string) string {
+        return hex.EncodeToString(sumHMAC(signingKey, []byte(stringToSign)))
+}
+
+// getScope generate a string of a specific date, an AWS region, and a
+// service.
+func getScope(location string, t time.Time, serviceType string) string {
+        scope := strings.Join([]string{
+                t.Format(yyyymmdd),
+                location,
+                serviceType,
+                "aws4_request",
+        }, "/")
+        return scope
+}
+
+// GetCredential generate a credential string.
+func GetCredential(accessKeyID, location string, t time.Time, serviceType string) string {
+        scope := getScope(location, t, serviceType)
+        return accessKeyID + "/" + scope
+}
+
+// getHashedPayload get the hexadecimal value of the SHA256 hash of
+// the request payload.
+func getHashedPayload(req http.Request) string {
+        hashedPayload := req.Header.Get("X-Amz-Content-Sha256")
+        if hashedPayload == "" {
+                // Presign does not have a payload, use S3 recommended value.
+                hashedPayload = unsignedPayload
+        }
+        return hashedPayload
+}
+
+// getCanonicalHeaders generate a list of request headers for
+// signature.
+func getCanonicalHeaders(req http.Request, ignoredHeaders map[string]bool) string {
+        var headers []string
+        vals := make(map[string][]string)
+        for k, vv := range req.Header {
+                if _, ok := ignoredHeaders[http.CanonicalHeaderKey(k)]; ok {
+                        continue // ignored header
+                }
+                headers = append(headers, strings.ToLower(k))
+                vals[strings.ToLower(k)] = vv
+        }
+        if !headerExists("host", headers) {
+                headers = append(headers, "host")
+        }
+        sort.Strings(headers)
+
+        var buf bytes.Buffer
+        // Save all the headers in canonical form <header>:<value> newline
+        // separated for each header.
+        for _, k := range headers {
+                buf.WriteString(k)
+                buf.WriteByte(':')
+                switch {
+                case k == "host":
+                        buf.WriteString(getHostAddr(&req))
+                        buf.WriteByte('\n')
+                default:
+                        for idx, v := range vals[k] {
+                                if idx > 0 {
+                                        buf.WriteByte(',')
+                                }
+                                buf.WriteString(signV4TrimAll(v))
+                        }
+                        buf.WriteByte('\n')
+                }
+        }
+        return buf.String()
+}
+
+func headerExists(key string, headers []string) bool {
+        for _, k := range headers {
+                if k == key {
+                        return true
+                }
+        }
+        return false
+}
+
+// getSignedHeaders generate all signed request headers.
+// i.e lexically sorted, semicolon-separated list of lowercase
+// request header names.
+func getSignedHeaders(req http.Request, ignoredHeaders map[string]bool) string {
+        var headers []string
+        for k := range req.Header {
+                if _, ok := ignoredHeaders[http.CanonicalHeaderKey(k)]; ok {
+                        continue // Ignored header found continue.
+                }
+                headers = append(headers, strings.ToLower(k))
+        }
+        if !headerExists("host", headers) {
+                headers = append(headers, "host")
+        }
+        sort.Strings(headers)
+        return strings.Join(headers, ";")
+}
+
+// getCanonicalRequest generate a canonical request of style.
+//
+// canonicalRequest =
+//
+//      <HTTPMethod>\n
+//      <CanonicalURI>\n
+//      <CanonicalQueryString>\n
+//      <CanonicalHeaders>\n
+//      <SignedHeaders>\n
+//      <HashedPayload>
+func getCanonicalRequest(req http.Request, ignoredHeaders map[string]bool, hashedPayload string) string {
+        req.URL.RawQuery = strings.ReplaceAll(req.URL.Query().Encode(), "+", "%20")
+        canonicalRequest := strings.Join([]string{
+                req.Method,
+                s3utils.EncodePath(req.URL.Path),
+                req.URL.RawQuery,
+                getCanonicalHeaders(req, ignoredHeaders),
+                getSignedHeaders(req, ignoredHeaders),
+                hashedPayload,
+        }, "\n")
+        return canonicalRequest
+}
+
+// getStringToSign a string based on selected query values.
+func getStringToSignV4(t time.Time, location, canonicalRequest, serviceType string) string {
+        stringToSign := signV4Algorithm + "\n" + t.Format(iso8601DateFormat) + "\n"
+        stringToSign = stringToSign + getScope(location, t, serviceType) + "\n"
+        stringToSign += hex.EncodeToString(sum256([]byte(canonicalRequest)))
+        return stringToSign
+}
+
+// PreSignV4 presign the request, in accordance with
+// http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html.
+func PreSignV4(req http.Request, accessKeyID, secretAccessKey, sessionToken, location string, expires int64) *http.Request {
+        // Presign is not needed for anonymous credentials.
+        if accessKeyID == "" || secretAccessKey == "" {
+                return &req
+        }
+
+        // Initial time.
+        t := time.Now().UTC()
+
+        // Get credential string.
+        credential := GetCredential(accessKeyID, location, t, ServiceTypeS3)
+
+        // Get all signed headers.
+        signedHeaders := getSignedHeaders(req, v4IgnoredHeaders)
+
+        // Set URL query.
+        query := req.URL.Query()
+        query.Set("X-Amz-Algorithm", signV4Algorithm)
+        query.Set("X-Amz-Date", t.Format(iso8601DateFormat))
+        query.Set("X-Amz-Expires", strconv.FormatInt(expires, 10))
+        query.Set("X-Amz-SignedHeaders", signedHeaders)
+        query.Set("X-Amz-Credential", credential)
+        // Set session token if available.
+        if sessionToken != "" {
+                query.Set("X-Amz-Security-Token", sessionToken)
+        }
+        req.URL.RawQuery = query.Encode()
+
+        // Get canonical request.
+        canonicalRequest := getCanonicalRequest(req, v4IgnoredHeaders, getHashedPayload(req))
+
+        // Get string to sign from canonical request.
+        stringToSign := getStringToSignV4(t, location, canonicalRequest, ServiceTypeS3)
+
+        // Gext hmac signing key.
+        signingKey := getSigningKey(secretAccessKey, location, t, ServiceTypeS3)
+
+        // Calculate signature.
+        signature := getSignature(signingKey, stringToSign)
+
+        // Add signature header to RawQuery.
+        req.URL.RawQuery += "&X-Amz-Signature=" + signature
+
+        return &req
+}
+
+// PostPresignSignatureV4 - presigned signature for PostPolicy
+// requests.
+func PostPresignSignatureV4(policyBase64 string, t time.Time, secretAccessKey, location string) string {
+        // Get signining key.
+        signingkey := getSigningKey(secretAccessKey, location, t, ServiceTypeS3)
+        // Calculate signature.
+        signature := getSignature(signingkey, policyBase64)
+        return signature
+}
+
+// SignV4STS - signature v4 for STS request.
+func SignV4STS(req http.Request, accessKeyID, secretAccessKey, location string) *http.Request {
+        return signV4(req, accessKeyID, secretAccessKey, "", location, ServiceTypeSTS, nil)
+}
+
+// Internal function called for different service types.
+func signV4(req http.Request, accessKeyID, secretAccessKey, sessionToken, location, serviceType string, trailer http.Header) *http.Request {
+        // Signature calculation is not needed for anonymous credentials.
+        if accessKeyID == "" || secretAccessKey == "" {
+                return &req
+        }
+
+        // Initial time.
+        t := time.Now().UTC()
+
+        // Set x-amz-date.
+        req.Header.Set("X-Amz-Date", t.Format(iso8601DateFormat))
+
+        // Set session token if available.
+        if sessionToken != "" {
+                req.Header.Set("X-Amz-Security-Token", sessionToken)
+        }
+
+        if len(trailer) > 0 {
+                for k := range trailer {
+                        req.Header.Add("X-Amz-Trailer", strings.ToLower(k))
+                }
+
+                req.Header.Set("Content-Encoding", "aws-chunked")
+                req.Header.Set("x-amz-decoded-content-length", strconv.FormatInt(req.ContentLength, 10))
+        }
+
+        hashedPayload := getHashedPayload(req)
+        if serviceType == ServiceTypeSTS {
+                // Content sha256 header is not sent with the request
+                // but it is expected to have sha256 of payload for signature
+                // in STS service type request.
+                req.Header.Del("X-Amz-Content-Sha256")
+        }
+
+        // Get canonical request.
+        canonicalRequest := getCanonicalRequest(req, v4IgnoredHeaders, hashedPayload)
+
+        // Get string to sign from canonical request.
+        stringToSign := getStringToSignV4(t, location, canonicalRequest, serviceType)
+
+        // Get hmac signing key.
+        signingKey := getSigningKey(secretAccessKey, location, t, serviceType)
+
+        // Get credential string.
+        credential := GetCredential(accessKeyID, location, t, serviceType)
+
+        // Get all signed headers.
+        signedHeaders := getSignedHeaders(req, v4IgnoredHeaders)
+
+        // Calculate signature.
+        signature := getSignature(signingKey, stringToSign)
+
+        // If regular request, construct the final authorization header.
+        parts := []string{
+                signV4Algorithm + " Credential=" + credential,
+                "SignedHeaders=" + signedHeaders,
+                "Signature=" + signature,
+        }
+
+        // Set authorization header.
+        auth := strings.Join(parts, ", ")
+        req.Header.Set("Authorization", auth)
+
+        if len(trailer) > 0 {
+                // Use custom chunked encoding.
+                req.Trailer = trailer
+                return StreamingUnsignedV4(&req, sessionToken, req.ContentLength, time.Now().UTC())
+        }
+        return &req
+}
+
+// SignV4 sign the request before Do(), in accordance with
+// http://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html.
+func SignV4(req http.Request, accessKeyID, secretAccessKey, sessionToken, location string) *http.Request {
+        return signV4(req, accessKeyID, secretAccessKey, sessionToken, location, ServiceTypeS3, nil)
+}
+
+// SignV4Trailer sign the request before Do(), in accordance with
+// http://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html
+func SignV4Trailer(req http.Request, accessKeyID, secretAccessKey, sessionToken, location string, trailer http.Header) *http.Request {
+        return signV4(req, accessKeyID, secretAccessKey, sessionToken, location, ServiceTypeS3, trailer)
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/signer/utils.go b/vendor/github.com/minio/minio-go/v7/pkg/signer/utils.go
new file mode 100644
index 0000000..87c9939
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/signer/utils.go
@@ -0,0 +1,62 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 signer
+
+import (
+        "crypto/hmac"
+        "crypto/sha256"
+        "net/http"
+        "strings"
+)
+
+// unsignedPayload - value to be set to X-Amz-Content-Sha256 header when
+const unsignedPayload = "UNSIGNED-PAYLOAD"
+
+// sum256 calculate sha256 sum for an input byte array.
+func sum256(data []byte) []byte {
+        hash := sha256.New()
+        hash.Write(data)
+        return hash.Sum(nil)
+}
+
+// sumHMAC calculate hmac between two input byte array.
+func sumHMAC(key, data []byte) []byte {
+        hash := hmac.New(sha256.New, key)
+        hash.Write(data)
+        return hash.Sum(nil)
+}
+
+// getHostAddr returns host header if available, otherwise returns host from URL
+func getHostAddr(req *http.Request) string {
+        host := req.Header.Get("host")
+        if host != "" && req.Host != host {
+                return host
+        }
+        if req.Host != "" {
+                return req.Host
+        }
+        return req.URL.Host
+}
+
+// Trim leading and trailing spaces and replace sequential spaces with one space, following Trimall()
+// in http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
+func signV4TrimAll(input string) string {
+        // Compress adjacent spaces (a space is determined by
+        // unicode.IsSpace() internally here) to one space and return
+        return strings.Join(strings.Fields(input), " ")
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/sse/sse.go b/vendor/github.com/minio/minio-go/v7/pkg/sse/sse.go
new file mode 100644
index 0000000..b5fb956
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/sse/sse.go
@@ -0,0 +1,66 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2020 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 sse
+
+import "encoding/xml"
+
+// ApplySSEByDefault defines default encryption configuration, KMS or SSE. To activate
+// KMS, SSEAlgoritm needs to be set to "aws:kms"
+// Minio currently does not support Kms.
+type ApplySSEByDefault struct {
+        KmsMasterKeyID string `xml:"KMSMasterKeyID,omitempty"`
+        SSEAlgorithm   string `xml:"SSEAlgorithm"`
+}
+
+// Rule layer encapsulates default encryption configuration
+type Rule struct {
+        Apply ApplySSEByDefault `xml:"ApplyServerSideEncryptionByDefault"`
+}
+
+// Configuration is the default encryption configuration structure
+type Configuration struct {
+        XMLName xml.Name `xml:"ServerSideEncryptionConfiguration"`
+        Rules   []Rule   `xml:"Rule"`
+}
+
+// NewConfigurationSSES3 initializes a new SSE-S3 configuration
+func NewConfigurationSSES3() *Configuration {
+        return &Configuration{
+                Rules: []Rule{
+                        {
+                                Apply: ApplySSEByDefault{
+                                        SSEAlgorithm: "AES256",
+                                },
+                        },
+                },
+        }
+}
+
+// NewConfigurationSSEKMS initializes a new SSE-KMS configuration
+func NewConfigurationSSEKMS(kmsMasterKey string) *Configuration {
+        return &Configuration{
+                Rules: []Rule{
+                        {
+                                Apply: ApplySSEByDefault{
+                                        KmsMasterKeyID: kmsMasterKey,
+                                        SSEAlgorithm:   "aws:kms",
+                                },
+                        },
+                },
+        }
+}
diff --git a/vendor/github.com/minio/minio-go/v7/pkg/tags/tags.go b/vendor/github.com/minio/minio-go/v7/pkg/tags/tags.go
new file mode 100644
index 0000000..7a84a6f
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/pkg/tags/tags.go
@@ -0,0 +1,413 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2020-2022 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 tags
+
+import (
+        "encoding/xml"
+        "io"
+        "net/url"
+        "regexp"
+        "sort"
+        "strings"
+        "unicode/utf8"
+)
+
+// Error contains tag specific error.
+type Error interface {
+        error
+        Code() string
+}
+
+type errTag struct {
+        code    string
+        message string
+}
+
+// Code contains error code.
+func (err errTag) Code() string {
+        return err.code
+}
+
+// Error contains error message.
+func (err errTag) Error() string {
+        return err.message
+}
+
+var (
+        errTooManyObjectTags = &errTag{"BadRequest", "Tags cannot be more than 10"}
+        errTooManyTags       = &errTag{"BadRequest", "Tags cannot be more than 50"}
+        errInvalidTagKey     = &errTag{"InvalidTag", "The TagKey you have provided is invalid"}
+        errInvalidTagValue   = &errTag{"InvalidTag", "The TagValue you have provided is invalid"}
+        errDuplicateTagKey   = &errTag{"InvalidTag", "Cannot provide multiple Tags with the same key"}
+)
+
+// Tag comes with limitation as per
+// https://docs.aws.amazon.com/AmazonS3/latest/dev/object-tagging.html amd
+// https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-restrictions
+const (
+        maxKeyLength      = 128
+        maxValueLength    = 256
+        maxObjectTagCount = 10
+        maxTagCount       = 50
+)
+
+// https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#tag-restrictions
+// borrowed from this article and also testing various ASCII characters following regex
+// is supported by AWS S3 for both tags and values.
+var validTagKeyValue = regexp.MustCompile(`^[a-zA-Z0-9-+\-._:/@ ]+$`)
+
+func checkKey(key string) error {
+        if len(key) == 0 {
+                return errInvalidTagKey
+        }
+
+        if utf8.RuneCountInString(key) > maxKeyLength || !validTagKeyValue.MatchString(key) {
+                return errInvalidTagKey
+        }
+
+        return nil
+}
+
+func checkValue(value string) error {
+        if value != "" {
+                if utf8.RuneCountInString(value) > maxValueLength || !validTagKeyValue.MatchString(value) {
+                        return errInvalidTagValue
+                }
+        }
+
+        return nil
+}
+
+// Tag denotes key and value.
+type Tag struct {
+        Key   string `xml:"Key"`
+        Value string `xml:"Value"`
+}
+
+func (tag Tag) String() string {
+        return tag.Key + "=" + tag.Value
+}
+
+// IsEmpty returns whether this tag is empty or not.
+func (tag Tag) IsEmpty() bool {
+        return tag.Key == ""
+}
+
+// Validate checks this tag.
+func (tag Tag) Validate() error {
+        if err := checkKey(tag.Key); err != nil {
+                return err
+        }
+
+        return checkValue(tag.Value)
+}
+
+// MarshalXML encodes to XML data.
+func (tag Tag) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+        if err := tag.Validate(); err != nil {
+                return err
+        }
+
+        type subTag Tag // to avoid recursively calling MarshalXML()
+        return e.EncodeElement(subTag(tag), start)
+}
+
+// UnmarshalXML decodes XML data to tag.
+func (tag *Tag) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+        type subTag Tag // to avoid recursively calling UnmarshalXML()
+        var st subTag
+        if err := d.DecodeElement(&st, &start); err != nil {
+                return err
+        }
+
+        if err := Tag(st).Validate(); err != nil {
+                return err
+        }
+
+        *tag = Tag(st)
+        return nil
+}
+
+// tagSet represents list of unique tags.
+type tagSet struct {
+        tagMap   map[string]string
+        isObject bool
+}
+
+func (tags tagSet) String() string {
+        if len(tags.tagMap) == 0 {
+                return ""
+        }
+        var buf strings.Builder
+        keys := make([]string, 0, len(tags.tagMap))
+        for k := range tags.tagMap {
+                keys = append(keys, k)
+        }
+        sort.Strings(keys)
+        for _, k := range keys {
+                keyEscaped := url.QueryEscape(k)
+                valueEscaped := url.QueryEscape(tags.tagMap[k])
+                if buf.Len() > 0 {
+                        buf.WriteByte('&')
+                }
+                buf.WriteString(keyEscaped)
+                buf.WriteByte('=')
+                buf.WriteString(valueEscaped)
+        }
+        return buf.String()
+}
+
+func (tags *tagSet) remove(key string) {
+        delete(tags.tagMap, key)
+}
+
+func (tags *tagSet) set(key, value string, failOnExist bool) error {
+        if failOnExist {
+                if _, found := tags.tagMap[key]; found {
+                        return errDuplicateTagKey
+                }
+        }
+
+        if err := checkKey(key); err != nil {
+                return err
+        }
+
+        if err := checkValue(value); err != nil {
+                return err
+        }
+
+        if tags.isObject {
+                if len(tags.tagMap) == maxObjectTagCount {
+                        return errTooManyObjectTags
+                }
+        } else if len(tags.tagMap) == maxTagCount {
+                return errTooManyTags
+        }
+
+        tags.tagMap[key] = value
+        return nil
+}
+
+func (tags tagSet) count() int {
+        return len(tags.tagMap)
+}
+
+func (tags tagSet) toMap() map[string]string {
+        m := make(map[string]string, len(tags.tagMap))
+        for key, value := range tags.tagMap {
+                m[key] = value
+        }
+        return m
+}
+
+// MarshalXML encodes to XML data.
+func (tags tagSet) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+        tagList := struct {
+                Tags []Tag `xml:"Tag"`
+        }{}
+
+        tagList.Tags = make([]Tag, 0, len(tags.tagMap))
+        for key, value := range tags.tagMap {
+                tagList.Tags = append(tagList.Tags, Tag{key, value})
+        }
+
+        return e.EncodeElement(tagList, start)
+}
+
+// UnmarshalXML decodes XML data to tag list.
+func (tags *tagSet) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+        tagList := struct {
+                Tags []Tag `xml:"Tag"`
+        }{}
+
+        if err := d.DecodeElement(&tagList, &start); err != nil {
+                return err
+        }
+
+        if tags.isObject {
+                if len(tagList.Tags) > maxObjectTagCount {
+                        return errTooManyObjectTags
+                }
+        } else if len(tagList.Tags) > maxTagCount {
+                return errTooManyTags
+        }
+
+        m := make(map[string]string, len(tagList.Tags))
+        for _, tag := range tagList.Tags {
+                if _, found := m[tag.Key]; found {
+                        return errDuplicateTagKey
+                }
+
+                m[tag.Key] = tag.Value
+        }
+
+        tags.tagMap = m
+        return nil
+}
+
+type tagging struct {
+        XMLName xml.Name `xml:"Tagging"`
+        TagSet  *tagSet  `xml:"TagSet"`
+}
+
+// Tags is list of tags of XML request/response as per
+// https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketTagging.html#API_GetBucketTagging_RequestBody
+type Tags tagging
+
+func (tags Tags) String() string {
+        return tags.TagSet.String()
+}
+
+// Remove removes a tag by its key.
+func (tags *Tags) Remove(key string) {
+        tags.TagSet.remove(key)
+}
+
+// Set sets new tag.
+func (tags *Tags) Set(key, value string) error {
+        return tags.TagSet.set(key, value, false)
+}
+
+// Count - return number of tags accounted for
+func (tags Tags) Count() int {
+        return tags.TagSet.count()
+}
+
+// ToMap returns copy of tags.
+func (tags Tags) ToMap() map[string]string {
+        return tags.TagSet.toMap()
+}
+
+// MapToObjectTags converts an input map of key and value into
+// *Tags data structure with validation.
+func MapToObjectTags(tagMap map[string]string) (*Tags, error) {
+        return NewTags(tagMap, true)
+}
+
+// MapToBucketTags converts an input map of key and value into
+// *Tags data structure with validation.
+func MapToBucketTags(tagMap map[string]string) (*Tags, error) {
+        return NewTags(tagMap, false)
+}
+
+// NewTags creates Tags from tagMap, If isObject is set, it validates for object tags.
+func NewTags(tagMap map[string]string, isObject bool) (*Tags, error) {
+        tagging := &Tags{
+                TagSet: &tagSet{
+                        tagMap:   make(map[string]string),
+                        isObject: isObject,
+                },
+        }
+
+        for key, value := range tagMap {
+                if err := tagging.TagSet.set(key, value, true); err != nil {
+                        return nil, err
+                }
+        }
+
+        return tagging, nil
+}
+
+func unmarshalXML(reader io.Reader, isObject bool) (*Tags, error) {
+        tagging := &Tags{
+                TagSet: &tagSet{
+                        tagMap:   make(map[string]string),
+                        isObject: isObject,
+                },
+        }
+
+        if err := xml.NewDecoder(reader).Decode(tagging); err != nil {
+                return nil, err
+        }
+
+        return tagging, nil
+}
+
+// ParseBucketXML decodes XML data of tags in reader specified in
+// https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketTagging.html#API_PutBucketTagging_RequestSyntax.
+func ParseBucketXML(reader io.Reader) (*Tags, error) {
+        return unmarshalXML(reader, false)
+}
+
+// ParseObjectXML decodes XML data of tags in reader specified in
+// https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html#API_PutObjectTagging_RequestSyntax
+func ParseObjectXML(reader io.Reader) (*Tags, error) {
+        return unmarshalXML(reader, true)
+}
+
+// stringsCut slices s around the first instance of sep,
+// returning the text before and after sep.
+// The found result reports whether sep appears in s.
+// If sep does not appear in s, cut returns s, "", false.
+func stringsCut(s, sep string) (before, after string, found bool) {
+        if i := strings.Index(s, sep); i >= 0 {
+                return s[:i], s[i+len(sep):], true
+        }
+        return s, "", false
+}
+
+func (tags *tagSet) parseTags(tgs string) (err error) {
+        for tgs != "" {
+                var key string
+                key, tgs, _ = stringsCut(tgs, "&")
+                if key == "" {
+                        continue
+                }
+                key, value, _ := stringsCut(key, "=")
+                key, err1 := url.QueryUnescape(key)
+                if err1 != nil {
+                        if err == nil {
+                                err = err1
+                        }
+                        continue
+                }
+                value, err1 = url.QueryUnescape(value)
+                if err1 != nil {
+                        if err == nil {
+                                err = err1
+                        }
+                        continue
+                }
+                if err = tags.set(key, value, true); err != nil {
+                        return err
+                }
+        }
+        return err
+}
+
+// Parse decodes HTTP query formatted string into tags which is limited by isObject.
+// A query formatted string is like "key1=value1&key2=value2".
+func Parse(s string, isObject bool) (*Tags, error) {
+        tagging := &Tags{
+                TagSet: &tagSet{
+                        tagMap:   make(map[string]string),
+                        isObject: isObject,
+                },
+        }
+
+        if err := tagging.TagSet.parseTags(s); err != nil {
+                return nil, err
+        }
+
+        return tagging, nil
+}
+
+// ParseObjectTags decodes HTTP query formatted string into tags. A query formatted string is like "key1=value1&key2=value2".
+func ParseObjectTags(s string) (*Tags, error) {
+        return Parse(s, true)
+}
diff --git a/vendor/github.com/minio/minio-go/v7/post-policy.go b/vendor/github.com/minio/minio-go/v7/post-policy.go
new file mode 100644
index 0000000..3f4881e
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/post-policy.go
@@ -0,0 +1,349 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-2023 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 minio
+
+import (
+        "encoding/base64"
+        "fmt"
+        "net/http"
+        "strings"
+        "time"
+
+        "github.com/minio/minio-go/v7/pkg/encrypt"
+)
+
+// expirationDateFormat date format for expiration key in json policy.
+const expirationDateFormat = "2006-01-02T15:04:05.000Z"
+
+// policyCondition explanation:
+// http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-HTTPPOSTConstructPolicy.html
+//
+// Example:
+//
+//      policyCondition {
+//          matchType: "$eq",
+//          key: "$Content-Type",
+//          value: "image/png",
+//      }
+type policyCondition struct {
+        matchType string
+        condition string
+        value     string
+}
+
+// PostPolicy - Provides strict static type conversion and validation
+// for Amazon S3's POST policy JSON string.
+type PostPolicy struct {
+        // Expiration date and time of the POST policy.
+        expiration time.Time
+        // Collection of different policy conditions.
+        conditions []policyCondition
+        // ContentLengthRange minimum and maximum allowable size for the
+        // uploaded content.
+        contentLengthRange struct {
+                min int64
+                max int64
+        }
+
+        // Post form data.
+        formData map[string]string
+}
+
+// NewPostPolicy - Instantiate new post policy.
+func NewPostPolicy() *PostPolicy {
+        p := &PostPolicy{}
+        p.conditions = make([]policyCondition, 0)
+        p.formData = make(map[string]string)
+        return p
+}
+
+// SetExpires - Sets expiration time for the new policy.
+func (p *PostPolicy) SetExpires(t time.Time) error {
+        if t.IsZero() {
+                return errInvalidArgument("No expiry time set.")
+        }
+        p.expiration = t
+        return nil
+}
+
+// SetKey - Sets an object name for the policy based upload.
+func (p *PostPolicy) SetKey(key string) error {
+        if strings.TrimSpace(key) == "" || key == "" {
+                return errInvalidArgument("Object name is empty.")
+        }
+        policyCond := policyCondition{
+                matchType: "eq",
+                condition: "$key",
+                value:     key,
+        }
+        if err := p.addNewPolicy(policyCond); err != nil {
+                return err
+        }
+        p.formData["key"] = key
+        return nil
+}
+
+// SetKeyStartsWith - Sets an object name that an policy based upload
+// can start with.
+// Can use an empty value ("") to allow any key.
+func (p *PostPolicy) SetKeyStartsWith(keyStartsWith string) error {
+        policyCond := policyCondition{
+                matchType: "starts-with",
+                condition: "$key",
+                value:     keyStartsWith,
+        }
+        if err := p.addNewPolicy(policyCond); err != nil {
+                return err
+        }
+        p.formData["key"] = keyStartsWith
+        return nil
+}
+
+// SetBucket - Sets bucket at which objects will be uploaded to.
+func (p *PostPolicy) SetBucket(bucketName string) error {
+        if strings.TrimSpace(bucketName) == "" || bucketName == "" {
+                return errInvalidArgument("Bucket name is empty.")
+        }
+        policyCond := policyCondition{
+                matchType: "eq",
+                condition: "$bucket",
+                value:     bucketName,
+        }
+        if err := p.addNewPolicy(policyCond); err != nil {
+                return err
+        }
+        p.formData["bucket"] = bucketName
+        return nil
+}
+
+// SetCondition - Sets condition for credentials, date and algorithm
+func (p *PostPolicy) SetCondition(matchType, condition, value string) error {
+        if strings.TrimSpace(value) == "" || value == "" {
+                return errInvalidArgument("No value specified for condition")
+        }
+
+        policyCond := policyCondition{
+                matchType: matchType,
+                condition: "$" + condition,
+                value:     value,
+        }
+        if condition == "X-Amz-Credential" || condition == "X-Amz-Date" || condition == "X-Amz-Algorithm" {
+                if err := p.addNewPolicy(policyCond); err != nil {
+                        return err
+                }
+                p.formData[condition] = value
+                return nil
+        }
+        return errInvalidArgument("Invalid condition in policy")
+}
+
+// SetContentType - Sets content-type of the object for this policy
+// based upload.
+func (p *PostPolicy) SetContentType(contentType string) error {
+        if strings.TrimSpace(contentType) == "" || contentType == "" {
+                return errInvalidArgument("No content type specified.")
+        }
+        policyCond := policyCondition{
+                matchType: "eq",
+                condition: "$Content-Type",
+                value:     contentType,
+        }
+        if err := p.addNewPolicy(policyCond); err != nil {
+                return err
+        }
+        p.formData["Content-Type"] = contentType
+        return nil
+}
+
+// SetContentTypeStartsWith - Sets what content-type of the object for this policy
+// based upload can start with.
+// Can use an empty value ("") to allow any content-type.
+func (p *PostPolicy) SetContentTypeStartsWith(contentTypeStartsWith string) error {
+        policyCond := policyCondition{
+                matchType: "starts-with",
+                condition: "$Content-Type",
+                value:     contentTypeStartsWith,
+        }
+        if err := p.addNewPolicy(policyCond); err != nil {
+                return err
+        }
+        p.formData["Content-Type"] = contentTypeStartsWith
+        return nil
+}
+
+// SetContentLengthRange - Set new min and max content length
+// condition for all incoming uploads.
+func (p *PostPolicy) SetContentLengthRange(min, max int64) error {
+        if min > max {
+                return errInvalidArgument("Minimum limit is larger than maximum limit.")
+        }
+        if min < 0 {
+                return errInvalidArgument("Minimum limit cannot be negative.")
+        }
+        if max <= 0 {
+                return errInvalidArgument("Maximum limit cannot be non-positive.")
+        }
+        p.contentLengthRange.min = min
+        p.contentLengthRange.max = max
+        return nil
+}
+
+// SetSuccessActionRedirect - Sets the redirect success url of the object for this policy
+// based upload.
+func (p *PostPolicy) SetSuccessActionRedirect(redirect string) error {
+        if strings.TrimSpace(redirect) == "" || redirect == "" {
+                return errInvalidArgument("Redirect is empty")
+        }
+        policyCond := policyCondition{
+                matchType: "eq",
+                condition: "$success_action_redirect",
+                value:     redirect,
+        }
+        if err := p.addNewPolicy(policyCond); err != nil {
+                return err
+        }
+        p.formData["success_action_redirect"] = redirect
+        return nil
+}
+
+// SetSuccessStatusAction - Sets the status success code of the object for this policy
+// based upload.
+func (p *PostPolicy) SetSuccessStatusAction(status string) error {
+        if strings.TrimSpace(status) == "" || status == "" {
+                return errInvalidArgument("Status is empty")
+        }
+        policyCond := policyCondition{
+                matchType: "eq",
+                condition: "$success_action_status",
+                value:     status,
+        }
+        if err := p.addNewPolicy(policyCond); err != nil {
+                return err
+        }
+        p.formData["success_action_status"] = status
+        return nil
+}
+
+// SetUserMetadata - Set user metadata as a key/value couple.
+// Can be retrieved through a HEAD request or an event.
+func (p *PostPolicy) SetUserMetadata(key, value string) error {
+        if strings.TrimSpace(key) == "" || key == "" {
+                return errInvalidArgument("Key is empty")
+        }
+        if strings.TrimSpace(value) == "" || value == "" {
+                return errInvalidArgument("Value is empty")
+        }
+        headerName := fmt.Sprintf("x-amz-meta-%s", key)
+        policyCond := policyCondition{
+                matchType: "eq",
+                condition: fmt.Sprintf("$%s", headerName),
+                value:     value,
+        }
+        if err := p.addNewPolicy(policyCond); err != nil {
+                return err
+        }
+        p.formData[headerName] = value
+        return nil
+}
+
+// SetChecksum sets the checksum of the request.
+func (p *PostPolicy) SetChecksum(c Checksum) {
+        if c.IsSet() {
+                p.formData[amzChecksumAlgo] = c.Type.String()
+                p.formData[c.Type.Key()] = c.Encoded()
+        }
+}
+
+// SetEncryption - sets encryption headers for POST API
+func (p *PostPolicy) SetEncryption(sse encrypt.ServerSide) {
+        if sse == nil {
+                return
+        }
+        h := http.Header{}
+        sse.Marshal(h)
+        for k, v := range h {
+                p.formData[k] = v[0]
+        }
+}
+
+// SetUserData - Set user data as a key/value couple.
+// Can be retrieved through a HEAD request or an event.
+func (p *PostPolicy) SetUserData(key, value string) error {
+        if key == "" {
+                return errInvalidArgument("Key is empty")
+        }
+        if value == "" {
+                return errInvalidArgument("Value is empty")
+        }
+        headerName := fmt.Sprintf("x-amz-%s", key)
+        policyCond := policyCondition{
+                matchType: "eq",
+                condition: fmt.Sprintf("$%s", headerName),
+                value:     value,
+        }
+        if err := p.addNewPolicy(policyCond); err != nil {
+                return err
+        }
+        p.formData[headerName] = value
+        return nil
+}
+
+// addNewPolicy - internal helper to validate adding new policies.
+// Can use starts-with with an empty value ("") to allow any content within a form field.
+func (p *PostPolicy) addNewPolicy(policyCond policyCondition) error {
+        if policyCond.matchType == "" || policyCond.condition == "" {
+                return errInvalidArgument("Policy fields are empty.")
+        }
+        if policyCond.matchType != "starts-with" && policyCond.value == "" {
+                return errInvalidArgument("Policy value is empty.")
+        }
+        p.conditions = append(p.conditions, policyCond)
+        return nil
+}
+
+// String function for printing policy in json formatted string.
+func (p PostPolicy) String() string {
+        return string(p.marshalJSON())
+}
+
+// marshalJSON - Provides Marshaled JSON in bytes.
+func (p PostPolicy) marshalJSON() []byte {
+        expirationStr := `"expiration":"` + p.expiration.Format(expirationDateFormat) + `"`
+        var conditionsStr string
+        conditions := []string{}
+        for _, po := range p.conditions {
+                conditions = append(conditions, fmt.Sprintf("[\"%s\",\"%s\",\"%s\"]", po.matchType, po.condition, po.value))
+        }
+        if p.contentLengthRange.min != 0 || p.contentLengthRange.max != 0 {
+                conditions = append(conditions, fmt.Sprintf("[\"content-length-range\", %d, %d]",
+                        p.contentLengthRange.min, p.contentLengthRange.max))
+        }
+        if len(conditions) > 0 {
+                conditionsStr = `"conditions":[` + strings.Join(conditions, ",") + "]"
+        }
+        retStr := "{"
+        retStr = retStr + expirationStr + ","
+        retStr += conditionsStr
+        retStr += "}"
+        return []byte(retStr)
+}
+
+// base64 - Produces base64 of PostPolicy's Marshaled json.
+func (p PostPolicy) base64() string {
+        return base64.StdEncoding.EncodeToString(p.marshalJSON())
+}
diff --git a/vendor/github.com/minio/minio-go/v7/retry-continous.go b/vendor/github.com/minio/minio-go/v7/retry-continous.go
new file mode 100644
index 0000000..bfeea95
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/retry-continous.go
@@ -0,0 +1,69 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 minio
+
+import "time"
+
+// newRetryTimerContinous creates a timer with exponentially increasing delays forever.
+func (c *Client) newRetryTimerContinous(unit, cap time.Duration, jitter float64, doneCh chan struct{}) <-chan int {
+        attemptCh := make(chan int)
+
+        // normalize jitter to the range [0, 1.0]
+        if jitter < NoJitter {
+                jitter = NoJitter
+        }
+        if jitter > MaxJitter {
+                jitter = MaxJitter
+        }
+
+        // computes the exponential backoff duration according to
+        // https://www.awsarchitectureblog.com/2015/03/backoff.html
+        exponentialBackoffWait := func(attempt int) time.Duration {
+                // 1<<uint(attempt) below could overflow, so limit the value of attempt
+                maxAttempt := 30
+                if attempt > maxAttempt {
+                        attempt = maxAttempt
+                }
+                // sleep = random_between(0, min(cap, base * 2 ** attempt))
+                sleep := unit * time.Duration(1<<uint(attempt))
+                if sleep > cap {
+                        sleep = cap
+                }
+                if jitter != NoJitter {
+                        sleep -= time.Duration(c.random.Float64() * float64(sleep) * jitter)
+                }
+                return sleep
+        }
+
+        go func() {
+                defer close(attemptCh)
+                var nextBackoff int
+                for {
+                        select {
+                        // Attempts starts.
+                        case attemptCh <- nextBackoff:
+                                nextBackoff++
+                        case <-doneCh:
+                                // Stop the routine.
+                                return
+                        }
+                        time.Sleep(exponentialBackoffWait(nextBackoff))
+                }
+        }()
+        return attemptCh
+}
diff --git a/vendor/github.com/minio/minio-go/v7/retry.go b/vendor/github.com/minio/minio-go/v7/retry.go
new file mode 100644
index 0000000..1c6105e
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/retry.go
@@ -0,0 +1,148 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 minio
+
+import (
+        "context"
+        "crypto/x509"
+        "errors"
+        "net/http"
+        "net/url"
+        "time"
+)
+
+// MaxRetry is the maximum number of retries before stopping.
+var MaxRetry = 10
+
+// MaxJitter will randomize over the full exponential backoff time
+const MaxJitter = 1.0
+
+// NoJitter disables the use of jitter for randomizing the exponential backoff time
+const NoJitter = 0.0
+
+// DefaultRetryUnit - default unit multiplicative per retry.
+// defaults to 200 * time.Millisecond
+var DefaultRetryUnit = 200 * time.Millisecond
+
+// DefaultRetryCap - Each retry attempt never waits no longer than
+// this maximum time duration.
+var DefaultRetryCap = time.Second
+
+// newRetryTimer creates a timer with exponentially increasing
+// delays until the maximum retry attempts are reached.
+func (c *Client) newRetryTimer(ctx context.Context, maxRetry int, unit, cap time.Duration, jitter float64) <-chan int {
+        attemptCh := make(chan int)
+
+        // computes the exponential backoff duration according to
+        // https://www.awsarchitectureblog.com/2015/03/backoff.html
+        exponentialBackoffWait := func(attempt int) time.Duration {
+                // normalize jitter to the range [0, 1.0]
+                if jitter < NoJitter {
+                        jitter = NoJitter
+                }
+                if jitter > MaxJitter {
+                        jitter = MaxJitter
+                }
+
+                // sleep = random_between(0, min(cap, base * 2 ** attempt))
+                sleep := unit * time.Duration(1<<uint(attempt))
+                if sleep > cap {
+                        sleep = cap
+                }
+                if jitter != NoJitter {
+                        sleep -= time.Duration(c.random.Float64() * float64(sleep) * jitter)
+                }
+                return sleep
+        }
+
+        go func() {
+                defer close(attemptCh)
+                for i := 0; i < maxRetry; i++ {
+                        select {
+                        case attemptCh <- i + 1:
+                        case <-ctx.Done():
+                                return
+                        }
+
+                        select {
+                        case <-time.After(exponentialBackoffWait(i)):
+                        case <-ctx.Done():
+                                return
+                        }
+                }
+        }()
+        return attemptCh
+}
+
+// List of AWS S3 error codes which are retryable.
+var retryableS3Codes = map[string]struct{}{
+        "RequestError":          {},
+        "RequestTimeout":        {},
+        "Throttling":            {},
+        "ThrottlingException":   {},
+        "RequestLimitExceeded":  {},
+        "RequestThrottled":      {},
+        "InternalError":         {},
+        "ExpiredToken":          {},
+        "ExpiredTokenException": {},
+        "SlowDown":              {},
+        // Add more AWS S3 codes here.
+}
+
+// isS3CodeRetryable - is s3 error code retryable.
+func isS3CodeRetryable(s3Code string) (ok bool) {
+        _, ok = retryableS3Codes[s3Code]
+        return ok
+}
+
+// List of HTTP status codes which are retryable.
+var retryableHTTPStatusCodes = map[int]struct{}{
+        429:                            {}, // http.StatusTooManyRequests is not part of the Go 1.5 library, yet
+        499:                            {}, // client closed request, retry. A non-standard status code introduced by nginx.
+        http.StatusInternalServerError: {},
+        http.StatusBadGateway:          {},
+        http.StatusServiceUnavailable:  {},
+        http.StatusGatewayTimeout:      {},
+        // Add more HTTP status codes here.
+}
+
+// isHTTPStatusRetryable - is HTTP error code retryable.
+func isHTTPStatusRetryable(httpStatusCode int) (ok bool) {
+        _, ok = retryableHTTPStatusCodes[httpStatusCode]
+        return ok
+}
+
+// For now, all http Do() requests are retriable except some well defined errors
+func isRequestErrorRetryable(err error) bool {
+        if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+                return false
+        }
+        if ue, ok := err.(*url.Error); ok {
+                e := ue.Unwrap()
+                switch e.(type) {
+                // x509: certificate signed by unknown authority
+                case x509.UnknownAuthorityError:
+                        return false
+                }
+                switch e.Error() {
+                case "http: server gave HTTP response to HTTPS client":
+                        return false
+                }
+        }
+        return true
+}
diff --git a/vendor/github.com/minio/minio-go/v7/s3-endpoints.go b/vendor/github.com/minio/minio-go/v7/s3-endpoints.go
new file mode 100644
index 0000000..b1de7b6
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/s3-endpoints.go
@@ -0,0 +1,64 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 minio
+
+// awsS3EndpointMap Amazon S3 endpoint map.
+var awsS3EndpointMap = map[string]string{
+        "us-east-1":      "s3.dualstack.us-east-1.amazonaws.com",
+        "us-east-2":      "s3.dualstack.us-east-2.amazonaws.com",
+        "us-west-2":      "s3.dualstack.us-west-2.amazonaws.com",
+        "us-west-1":      "s3.dualstack.us-west-1.amazonaws.com",
+        "ca-central-1":   "s3.dualstack.ca-central-1.amazonaws.com",
+        "eu-west-1":      "s3.dualstack.eu-west-1.amazonaws.com",
+        "eu-west-2":      "s3.dualstack.eu-west-2.amazonaws.com",
+        "eu-west-3":      "s3.dualstack.eu-west-3.amazonaws.com",
+        "eu-central-1":   "s3.dualstack.eu-central-1.amazonaws.com",
+        "eu-central-2":   "s3.dualstack.eu-central-2.amazonaws.com",
+        "eu-north-1":     "s3.dualstack.eu-north-1.amazonaws.com",
+        "eu-south-1":     "s3.dualstack.eu-south-1.amazonaws.com",
+        "eu-south-2":     "s3.dualstack.eu-south-2.amazonaws.com",
+        "ap-east-1":      "s3.dualstack.ap-east-1.amazonaws.com",
+        "ap-south-1":     "s3.dualstack.ap-south-1.amazonaws.com",
+        "ap-south-2":     "s3.dualstack.ap-south-2.amazonaws.com",
+        "ap-southeast-1": "s3.dualstack.ap-southeast-1.amazonaws.com",
+        "ap-southeast-2": "s3.dualstack.ap-southeast-2.amazonaws.com",
+        "ap-northeast-1": "s3.dualstack.ap-northeast-1.amazonaws.com",
+        "ap-northeast-2": "s3.dualstack.ap-northeast-2.amazonaws.com",
+        "ap-northeast-3": "s3.dualstack.ap-northeast-3.amazonaws.com",
+        "af-south-1":     "s3.dualstack.af-south-1.amazonaws.com",
+        "me-central-1":   "s3.dualstack.me-central-1.amazonaws.com",
+        "me-south-1":     "s3.dualstack.me-south-1.amazonaws.com",
+        "sa-east-1":      "s3.dualstack.sa-east-1.amazonaws.com",
+        "us-gov-west-1":  "s3.dualstack.us-gov-west-1.amazonaws.com",
+        "us-gov-east-1":  "s3.dualstack.us-gov-east-1.amazonaws.com",
+        "cn-north-1":     "s3.dualstack.cn-north-1.amazonaws.com.cn",
+        "cn-northwest-1": "s3.dualstack.cn-northwest-1.amazonaws.com.cn",
+        "ap-southeast-3": "s3.dualstack.ap-southeast-3.amazonaws.com",
+        "ap-southeast-4": "s3.dualstack.ap-southeast-4.amazonaws.com",
+        "il-central-1":   "s3.dualstack.il-central-1.amazonaws.com",
+}
+
+// getS3Endpoint get Amazon S3 endpoint based on the bucket location.
+func getS3Endpoint(bucketLocation string) (s3Endpoint string) {
+        s3Endpoint, ok := awsS3EndpointMap[bucketLocation]
+        if !ok {
+                // Default to 's3.dualstack.us-east-1.amazonaws.com' endpoint.
+                s3Endpoint = "s3.dualstack.us-east-1.amazonaws.com"
+        }
+        return s3Endpoint
+}
diff --git a/vendor/github.com/minio/minio-go/v7/s3-error.go b/vendor/github.com/minio/minio-go/v7/s3-error.go
new file mode 100644
index 0000000..f365157
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/s3-error.go
@@ -0,0 +1,61 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 minio
+
+// Non exhaustive list of AWS S3 standard error responses -
+// http://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html
+var s3ErrorResponseMap = map[string]string{
+        "AccessDenied":                      "Access Denied.",
+        "BadDigest":                         "The Content-Md5 you specified did not match what we received.",
+        "EntityTooSmall":                    "Your proposed upload is smaller than the minimum allowed object size.",
+        "EntityTooLarge":                    "Your proposed upload exceeds the maximum allowed object size.",
+        "IncompleteBody":                    "You did not provide the number of bytes specified by the Content-Length HTTP header.",
+        "InternalError":                     "We encountered an internal error, please try again.",
+        "InvalidAccessKeyId":                "The access key ID you provided does not exist in our records.",
+        "InvalidBucketName":                 "The specified bucket is not valid.",
+        "InvalidDigest":                     "The Content-Md5 you specified is not valid.",
+        "InvalidRange":                      "The requested range is not satisfiable",
+        "MalformedXML":                      "The XML you provided was not well-formed or did not validate against our published schema.",
+        "MissingContentLength":              "You must provide the Content-Length HTTP header.",
+        "MissingContentMD5":                 "Missing required header for this request: Content-Md5.",
+        "MissingRequestBodyError":           "Request body is empty.",
+        "NoSuchBucket":                      "The specified bucket does not exist.",
+        "NoSuchBucketPolicy":                "The bucket policy does not exist",
+        "NoSuchKey":                         "The specified key does not exist.",
+        "NoSuchUpload":                      "The specified multipart upload does not exist. The upload ID may be invalid, or the upload may have been aborted or completed.",
+        "NotImplemented":                    "A header you provided implies functionality that is not implemented",
+        "PreconditionFailed":                "At least one of the pre-conditions you specified did not hold",
+        "RequestTimeTooSkewed":              "The difference between the request time and the server's time is too large.",
+        "SignatureDoesNotMatch":             "The request signature we calculated does not match the signature you provided. Check your key and signing method.",
+        "MethodNotAllowed":                  "The specified method is not allowed against this resource.",
+        "InvalidPart":                       "One or more of the specified parts could not be found.",
+        "InvalidPartOrder":                  "The list of parts was not in ascending order. The parts list must be specified in order by part number.",
+        "InvalidObjectState":                "The operation is not valid for the current state of the object.",
+        "AuthorizationHeaderMalformed":      "The authorization header is malformed; the region is wrong.",
+        "MalformedPOSTRequest":              "The body of your POST request is not well-formed multipart/form-data.",
+        "BucketNotEmpty":                    "The bucket you tried to delete is not empty",
+        "AllAccessDisabled":                 "All access to this bucket has been disabled.",
+        "MalformedPolicy":                   "Policy has invalid resource.",
+        "MissingFields":                     "Missing fields in request.",
+        "AuthorizationQueryParametersError": "Error parsing the X-Amz-Credential parameter; the Credential is mal-formed; expecting \"<YOUR-AKID>/YYYYMMDD/REGION/SERVICE/aws4_request\".",
+        "MalformedDate":                     "Invalid date format header, expected to be in ISO8601, RFC1123 or RFC1123Z time format.",
+        "BucketAlreadyOwnedByYou":           "Your previous request to create the named bucket succeeded and you already own it.",
+        "InvalidDuration":                   "Duration provided in the request is invalid.",
+        "XAmzContentSHA256Mismatch":         "The provided 'x-amz-content-sha256' header does not match what was computed.",
+        // Add new API errors here.
+}
diff --git a/vendor/github.com/minio/minio-go/v7/transport.go b/vendor/github.com/minio/minio-go/v7/transport.go
new file mode 100644
index 0000000..1bff664
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/transport.go
@@ -0,0 +1,83 @@
+//go:build go1.7 || go1.8
+// +build go1.7 go1.8
+
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2017-2018 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 minio
+
+import (
+        "crypto/tls"
+        "crypto/x509"
+        "net"
+        "net/http"
+        "os"
+        "time"
+)
+
+// mustGetSystemCertPool - return system CAs or empty pool in case of error (or windows)
+func mustGetSystemCertPool() *x509.CertPool {
+        pool, err := x509.SystemCertPool()
+        if err != nil {
+                return x509.NewCertPool()
+        }
+        return pool
+}
+
+// DefaultTransport - this default transport is similar to
+// http.DefaultTransport but with additional param  DisableCompression
+// is set to true to avoid decompressing content with 'gzip' encoding.
+var DefaultTransport = func(secure bool) (*http.Transport, error) {
+        tr := &http.Transport{
+                Proxy: http.ProxyFromEnvironment,
+                DialContext: (&net.Dialer{
+                        Timeout:   30 * time.Second,
+                        KeepAlive: 30 * time.Second,
+                }).DialContext,
+                MaxIdleConns:          256,
+                MaxIdleConnsPerHost:   16,
+                ResponseHeaderTimeout: time.Minute,
+                IdleConnTimeout:       time.Minute,
+                TLSHandshakeTimeout:   10 * time.Second,
+                ExpectContinueTimeout: 10 * time.Second,
+                // Set this value so that the underlying transport round-tripper
+                // doesn't try to auto decode the body of objects with
+                // content-encoding set to `gzip`.
+                //
+                // Refer:
+                //    https://golang.org/src/net/http/transport.go?h=roundTrip#L1843
+                DisableCompression: true,
+        }
+
+        if secure {
+                tr.TLSClientConfig = &tls.Config{
+                        // Can't use SSLv3 because of POODLE and BEAST
+                        // Can't use TLSv1.0 because of POODLE and BEAST using CBC cipher
+                        // Can't use TLSv1.1 because of RC4 cipher usage
+                        MinVersion: tls.VersionTLS12,
+                }
+                if f := os.Getenv("SSL_CERT_FILE"); f != "" {
+                        rootCAs := mustGetSystemCertPool()
+                        data, err := os.ReadFile(f)
+                        if err == nil {
+                                rootCAs.AppendCertsFromPEM(data)
+                        }
+                        tr.TLSClientConfig.RootCAs = rootCAs
+                }
+        }
+        return tr, nil
+}
diff --git a/vendor/github.com/minio/minio-go/v7/utils.go b/vendor/github.com/minio/minio-go/v7/utils.go
new file mode 100644
index 0000000..e39eba0
--- /dev/null
+++ b/vendor/github.com/minio/minio-go/v7/utils.go
@@ -0,0 +1,693 @@
+/*
+ * MinIO Go Library for Amazon S3 Compatible Cloud Storage
+ * Copyright 2015-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 minio
+
+import (
+        "context"
+        "crypto/md5"
+        fipssha256 "crypto/sha256"
+        "encoding/base64"
+        "encoding/hex"
+        "encoding/xml"
+        "errors"
+        "fmt"
+        "hash"
+        "io"
+        "math/rand"
+        "net"
+        "net/http"
+        "net/url"
+        "regexp"
+        "strconv"
+        "strings"
+        "sync"
+        "time"
+
+        md5simd "github.com/minio/md5-simd"
+        "github.com/minio/minio-go/v7/pkg/encrypt"
+        "github.com/minio/minio-go/v7/pkg/s3utils"
+        "github.com/minio/sha256-simd"
+)
+
+func trimEtag(etag string) string {
+        etag = strings.TrimPrefix(etag, "\"")
+        return strings.TrimSuffix(etag, "\"")
+}
+
+var expirationRegex = regexp.MustCompile(`expiry-date="(.*?)", rule-id="(.*?)"`)
+
+func amzExpirationToExpiryDateRuleID(expiration string) (time.Time, string) {
+        if matches := expirationRegex.FindStringSubmatch(expiration); len(matches) == 3 {
+                expTime, err := parseRFC7231Time(matches[1])
+                if err != nil {
+                        return time.Time{}, ""
+                }
+                return expTime, matches[2]
+        }
+        return time.Time{}, ""
+}
+
+var restoreRegex = regexp.MustCompile(`ongoing-request="(.*?)"(, expiry-date="(.*?)")?`)
+
+func amzRestoreToStruct(restore string) (ongoing bool, expTime time.Time, err error) {
+        matches := restoreRegex.FindStringSubmatch(restore)
+        if len(matches) != 4 {
+                return false, time.Time{}, errors.New("unexpected restore header")
+        }
+        ongoing, err = strconv.ParseBool(matches[1])
+        if err != nil {
+                return false, time.Time{}, err
+        }
+        if matches[3] != "" {
+                expTime, err = parseRFC7231Time(matches[3])
+                if err != nil {
+                        return false, time.Time{}, err
+                }
+        }
+        return
+}
+
+// xmlDecoder provide decoded value in xml.
+func xmlDecoder(body io.Reader, v interface{}) error {
+        d := xml.NewDecoder(body)
+        return d.Decode(v)
+}
+
+// sum256 calculate sha256sum for an input byte array, returns hex encoded.
+func sum256Hex(data []byte) string {
+        hash := newSHA256Hasher()
+        defer hash.Close()
+        hash.Write(data)
+        return hex.EncodeToString(hash.Sum(nil))
+}
+
+// sumMD5Base64 calculate md5sum for an input byte array, returns base64 encoded.
+func sumMD5Base64(data []byte) string {
+        hash := newMd5Hasher()
+        defer hash.Close()
+        hash.Write(data)
+        return base64.StdEncoding.EncodeToString(hash.Sum(nil))
+}
+
+// getEndpointURL - construct a new endpoint.
+func getEndpointURL(endpoint string, secure bool) (*url.URL, error) {
+        // If secure is false, use 'http' scheme.
+        scheme := "https"
+        if !secure {
+                scheme = "http"
+        }
+
+        // Construct a secured endpoint URL.
+        endpointURLStr := scheme + "://" + endpoint
+        endpointURL, err := url.Parse(endpointURLStr)
+        if err != nil {
+                return nil, err
+        }
+
+        // Validate incoming endpoint URL.
+        if err := isValidEndpointURL(*endpointURL); err != nil {
+                return nil, err
+        }
+        return endpointURL, nil
+}
+
+// closeResponse close non nil response with any response Body.
+// convenient wrapper to drain any remaining data on response body.
+//
+// Subsequently this allows golang http RoundTripper
+// to re-use the same connection for future requests.
+func closeResponse(resp *http.Response) {
+        // Callers should close resp.Body when done reading from it.
+        // If resp.Body is not closed, the Client's underlying RoundTripper
+        // (typically Transport) may not be able to re-use a persistent TCP
+        // connection to the server for a subsequent "keep-alive" request.
+        if resp != nil && resp.Body != nil {
+                // Drain any remaining Body and then close the connection.
+                // Without this closing connection would disallow re-using
+                // the same connection for future uses.
+                //  - http://stackoverflow.com/a/17961593/4465767
+                io.Copy(io.Discard, resp.Body)
+                resp.Body.Close()
+        }
+}
+
+var (
+        // Hex encoded string of nil sha256sum bytes.
+        emptySHA256Hex = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+
+        // Sentinel URL is the default url value which is invalid.
+        sentinelURL = url.URL{}
+)
+
+// Verify if input endpoint URL is valid.
+func isValidEndpointURL(endpointURL url.URL) error {
+        if endpointURL == sentinelURL {
+                return errInvalidArgument("Endpoint url cannot be empty.")
+        }
+        if endpointURL.Path != "/" && endpointURL.Path != "" {
+                return errInvalidArgument("Endpoint url cannot have fully qualified paths.")
+        }
+        host := endpointURL.Hostname()
+        if !s3utils.IsValidIP(host) && !s3utils.IsValidDomain(host) {
+                msg := "Endpoint: " + endpointURL.Host + " does not follow ip address or domain name standards."
+                return errInvalidArgument(msg)
+        }
+
+        if strings.Contains(host, ".s3.amazonaws.com") {
+                if !s3utils.IsAmazonEndpoint(endpointURL) {
+                        return errInvalidArgument("Amazon S3 endpoint should be 's3.amazonaws.com'.")
+                }
+        }
+        if strings.Contains(host, ".googleapis.com") {
+                if !s3utils.IsGoogleEndpoint(endpointURL) {
+                        return errInvalidArgument("Google Cloud Storage endpoint should be 'storage.googleapis.com'.")
+                }
+        }
+        return nil
+}
+
+// Verify if input expires value is valid.
+func isValidExpiry(expires time.Duration) error {
+        expireSeconds := int64(expires / time.Second)
+        if expireSeconds < 1 {
+                return errInvalidArgument("Expires cannot be lesser than 1 second.")
+        }
+        if expireSeconds > 604800 {
+                return errInvalidArgument("Expires cannot be greater than 7 days.")
+        }
+        return nil
+}
+
+// Extract only necessary metadata header key/values by
+// filtering them out with a list of custom header keys.
+func extractObjMetadata(header http.Header) http.Header {
+        preserveKeys := []string{
+                "Content-Type",
+                "Cache-Control",
+                "Content-Encoding",
+                "Content-Language",
+                "Content-Disposition",
+                "X-Amz-Storage-Class",
+                "X-Amz-Object-Lock-Mode",
+                "X-Amz-Object-Lock-Retain-Until-Date",
+                "X-Amz-Object-Lock-Legal-Hold",
+                "X-Amz-Website-Redirect-Location",
+                "X-Amz-Server-Side-Encryption",
+                "X-Amz-Tagging-Count",
+                "X-Amz-Meta-",
+                // Add new headers to be preserved.
+                // if you add new headers here, please extend
+                // PutObjectOptions{} to preserve them
+                // upon upload as well.
+        }
+        filteredHeader := make(http.Header)
+        for k, v := range header {
+                var found bool
+                for _, prefix := range preserveKeys {
+                        if !strings.HasPrefix(k, prefix) {
+                                continue
+                        }
+                        found = true
+                        break
+                }
+                if found {
+                        filteredHeader[k] = v
+                }
+        }
+        return filteredHeader
+}
+
+const (
+        // RFC 7231#section-7.1.1.1 timetamp format. e.g Tue, 29 Apr 2014 18:30:38 GMT
+        rfc822TimeFormat                           = "Mon, 2 Jan 2006 15:04:05 GMT"
+        rfc822TimeFormatSingleDigitDay             = "Mon, _2 Jan 2006 15:04:05 GMT"
+        rfc822TimeFormatSingleDigitDayTwoDigitYear = "Mon, _2 Jan 06 15:04:05 GMT"
+)
+
+func parseTime(t string, formats ...string) (time.Time, error) {
+        for _, format := range formats {
+                tt, err := time.Parse(format, t)
+                if err == nil {
+                        return tt, nil
+                }
+        }
+        return time.Time{}, fmt.Errorf("unable to parse %s in any of the input formats: %s", t, formats)
+}
+
+func parseRFC7231Time(lastModified string) (time.Time, error) {
+        return parseTime(lastModified, rfc822TimeFormat, rfc822TimeFormatSingleDigitDay, rfc822TimeFormatSingleDigitDayTwoDigitYear)
+}
+
+// ToObjectInfo converts http header values into ObjectInfo type,
+// extracts metadata and fills in all the necessary fields in ObjectInfo.
+func ToObjectInfo(bucketName, objectName string, h http.Header) (ObjectInfo, error) {
+        var err error
+        // Trim off the odd double quotes from ETag in the beginning and end.
+        etag := trimEtag(h.Get("ETag"))
+
+        // Parse content length is exists
+        var size int64 = -1
+        contentLengthStr := h.Get("Content-Length")
+        if contentLengthStr != "" {
+                size, err = strconv.ParseInt(contentLengthStr, 10, 64)
+                if err != nil {
+                        // Content-Length is not valid
+                        return ObjectInfo{}, ErrorResponse{
+                                Code:       "InternalError",
+                                Message:    fmt.Sprintf("Content-Length is not an integer, failed with %v", err),
+                                BucketName: bucketName,
+                                Key:        objectName,
+                                RequestID:  h.Get("x-amz-request-id"),
+                                HostID:     h.Get("x-amz-id-2"),
+                                Region:     h.Get("x-amz-bucket-region"),
+                        }
+                }
+        }
+
+        // Parse Last-Modified has http time format.
+        mtime, err := parseRFC7231Time(h.Get("Last-Modified"))
+        if err != nil {
+                return ObjectInfo{}, ErrorResponse{
+                        Code:       "InternalError",
+                        Message:    fmt.Sprintf("Last-Modified time format is invalid, failed with %v", err),
+                        BucketName: bucketName,
+                        Key:        objectName,
+                        RequestID:  h.Get("x-amz-request-id"),
+                        HostID:     h.Get("x-amz-id-2"),
+                        Region:     h.Get("x-amz-bucket-region"),
+                }
+        }
+
+        // Fetch content type if any present.
+        contentType := strings.TrimSpace(h.Get("Content-Type"))
+        if contentType == "" {
+                contentType = "application/octet-stream"
+        }
+
+        expiryStr := h.Get("Expires")
+        var expiry time.Time
+        if expiryStr != "" {
+                expiry, err = parseRFC7231Time(expiryStr)
+                if err != nil {
+                        return ObjectInfo{}, ErrorResponse{
+                                Code:       "InternalError",
+                                Message:    fmt.Sprintf("'Expiry' is not in supported format: %v", err),
+                                BucketName: bucketName,
+                                Key:        objectName,
+                                RequestID:  h.Get("x-amz-request-id"),
+                                HostID:     h.Get("x-amz-id-2"),
+                                Region:     h.Get("x-amz-bucket-region"),
+                        }
+                }
+        }
+
+        metadata := extractObjMetadata(h)
+        userMetadata := make(map[string]string)
+        for k, v := range metadata {
+                if strings.HasPrefix(k, "X-Amz-Meta-") {
+                        userMetadata[strings.TrimPrefix(k, "X-Amz-Meta-")] = v[0]
+                }
+        }
+        userTags := s3utils.TagDecode(h.Get(amzTaggingHeader))
+
+        var tagCount int
+        if count := h.Get(amzTaggingCount); count != "" {
+                tagCount, err = strconv.Atoi(count)
+                if err != nil {
+                        return ObjectInfo{}, ErrorResponse{
+                                Code:       "InternalError",
+                                Message:    fmt.Sprintf("x-amz-tagging-count is not an integer, failed with %v", err),
+                                BucketName: bucketName,
+                                Key:        objectName,
+                                RequestID:  h.Get("x-amz-request-id"),
+                                HostID:     h.Get("x-amz-id-2"),
+                                Region:     h.Get("x-amz-bucket-region"),
+                        }
+                }
+        }
+
+        // Nil if not found
+        var restore *RestoreInfo
+        if restoreHdr := h.Get(amzRestore); restoreHdr != "" {
+                ongoing, expTime, err := amzRestoreToStruct(restoreHdr)
+                if err != nil {
+                        return ObjectInfo{}, err
+                }
+                restore = &RestoreInfo{OngoingRestore: ongoing, ExpiryTime: expTime}
+        }
+
+        // extract lifecycle expiry date and rule ID
+        expTime, ruleID := amzExpirationToExpiryDateRuleID(h.Get(amzExpiration))
+
+        deleteMarker := h.Get(amzDeleteMarker) == "true"
+
+        // Save object metadata info.
+        return ObjectInfo{
+                ETag:              etag,
+                Key:               objectName,
+                Size:              size,
+                LastModified:      mtime,
+                ContentType:       contentType,
+                Expires:           expiry,
+                VersionID:         h.Get(amzVersionID),
+                IsDeleteMarker:    deleteMarker,
+                ReplicationStatus: h.Get(amzReplicationStatus),
+                Expiration:        expTime,
+                ExpirationRuleID:  ruleID,
+                // Extract only the relevant header keys describing the object.
+                // following function filters out a list of standard set of keys
+                // which are not part of object metadata.
+                Metadata:     metadata,
+                UserMetadata: userMetadata,
+                UserTags:     userTags,
+                UserTagCount: tagCount,
+                Restore:      restore,
+
+                // Checksum values
+                ChecksumCRC32:  h.Get("x-amz-checksum-crc32"),
+                ChecksumCRC32C: h.Get("x-amz-checksum-crc32c"),
+                ChecksumSHA1:   h.Get("x-amz-checksum-sha1"),
+                ChecksumSHA256: h.Get("x-amz-checksum-sha256"),
+        }, nil
+}
+
+var readFull = func(r io.Reader, buf []byte) (n int, err error) {
+        // ReadFull reads exactly len(buf) bytes from r into buf.
+        // It returns the number of bytes copied and an error if
+        // fewer bytes were read. The error is EOF only if no bytes
+        // were read. If an EOF happens after reading some but not
+        // all the bytes, ReadFull returns ErrUnexpectedEOF.
+        // On return, n == len(buf) if and only if err == nil.
+        // If r returns an error having read at least len(buf) bytes,
+        // the error is dropped.
+        for n < len(buf) && err == nil {
+                var nn int
+                nn, err = r.Read(buf[n:])
+                // Some spurious io.Reader's return
+                // io.ErrUnexpectedEOF when nn == 0
+                // this behavior is undocumented
+                // so we are on purpose not using io.ReadFull
+                // implementation because this can lead
+                // to custom handling, to avoid that
+                // we simply modify the original io.ReadFull
+                // implementation to avoid this issue.
+                // io.ErrUnexpectedEOF with nn == 0 really
+                // means that io.EOF
+                if err == io.ErrUnexpectedEOF && nn == 0 {
+                        err = io.EOF
+                }
+                n += nn
+        }
+        if n >= len(buf) {
+                err = nil
+        } else if n > 0 && err == io.EOF {
+                err = io.ErrUnexpectedEOF
+        }
+        return
+}
+
+// regCred matches credential string in HTTP header
+var regCred = regexp.MustCompile("Credential=([A-Z0-9]+)/")
+
+// regCred matches signature string in HTTP header
+var regSign = regexp.MustCompile("Signature=([[0-9a-f]+)")
+
+// Redact out signature value from authorization string.
+func redactSignature(origAuth string) string {
+        if !strings.HasPrefix(origAuth, signV4Algorithm) {
+                // Set a temporary redacted auth
+                return "AWS **REDACTED**:**REDACTED**"
+        }
+
+        // Signature V4 authorization header.
+
+        // Strip out accessKeyID from:
+        // Credential=<access-key-id>/<date>/<aws-region>/<aws-service>/aws4_request
+        newAuth := regCred.ReplaceAllString(origAuth, "Credential=**REDACTED**/")
+
+        // Strip out 256-bit signature from: Signature=<256-bit signature>
+        return regSign.ReplaceAllString(newAuth, "Signature=**REDACTED**")
+}
+
+// Get default location returns the location based on the input
+// URL `u`, if region override is provided then all location
+// defaults to regionOverride.
+//
+// If no other cases match then the location is set to `us-east-1`
+// as a last resort.
+func getDefaultLocation(u url.URL, regionOverride string) (location string) {
+        if regionOverride != "" {
+                return regionOverride
+        }
+        region := s3utils.GetRegionFromURL(u)
+        if region == "" {
+                region = "us-east-1"
+        }
+        return region
+}
+
+var supportedHeaders = map[string]bool{
+        "content-type":                        true,
+        "cache-control":                       true,
+        "content-encoding":                    true,
+        "content-disposition":                 true,
+        "content-language":                    true,
+        "x-amz-website-redirect-location":     true,
+        "x-amz-object-lock-mode":              true,
+        "x-amz-metadata-directive":            true,
+        "x-amz-object-lock-retain-until-date": true,
+        "expires":                             true,
+        "x-amz-replication-status":            true,
+        // Add more supported headers here.
+        // Must be lower case.
+}
+
+// isStorageClassHeader returns true if the header is a supported storage class header
+func isStorageClassHeader(headerKey string) bool {
+        return strings.EqualFold(amzStorageClass, headerKey)
+}
+
+// isStandardHeader returns true if header is a supported header and not a custom header
+func isStandardHeader(headerKey string) bool {
+        return supportedHeaders[strings.ToLower(headerKey)]
+}
+
+// sseHeaders is list of server side encryption headers
+var sseHeaders = map[string]bool{
+        "x-amz-server-side-encryption":                    true,
+        "x-amz-server-side-encryption-aws-kms-key-id":     true,
+        "x-amz-server-side-encryption-context":            true,
+        "x-amz-server-side-encryption-customer-algorithm": true,
+        "x-amz-server-side-encryption-customer-key":       true,
+        "x-amz-server-side-encryption-customer-key-md5":   true,
+        // Add more supported headers here.
+        // Must be lower case.
+}
+
+// isSSEHeader returns true if header is a server side encryption header.
+func isSSEHeader(headerKey string) bool {
+        return sseHeaders[strings.ToLower(headerKey)]
+}
+
+// isAmzHeader returns true if header is a x-amz-meta-* or x-amz-acl header.
+func isAmzHeader(headerKey string) bool {
+        key := strings.ToLower(headerKey)
+
+        return strings.HasPrefix(key, "x-amz-meta-") || strings.HasPrefix(key, "x-amz-grant-") || key == "x-amz-acl" || isSSEHeader(headerKey) || strings.HasPrefix(key, "x-amz-checksum-")
+}
+
+// supportedQueryValues is a list of query strings that can be passed in when using GetObject.
+var supportedQueryValues = map[string]bool{
+        "partNumber":                   true,
+        "versionId":                    true,
+        "response-cache-control":       true,
+        "response-content-disposition": true,
+        "response-content-encoding":    true,
+        "response-content-language":    true,
+        "response-content-type":        true,
+        "response-expires":             true,
+}
+
+// isStandardQueryValue will return true when the passed in query string parameter is supported rather than customized.
+func isStandardQueryValue(qsKey string) bool {
+        return supportedQueryValues[qsKey]
+}
+
+// Per documentation at https://docs.aws.amazon.com/AmazonS3/latest/userguide/LogFormat.html#LogFormatCustom, the
+// set of query params starting with "x-" are ignored by S3.
+const allowedCustomQueryPrefix = "x-"
+
+func isCustomQueryValue(qsKey string) bool {
+        return strings.HasPrefix(qsKey, allowedCustomQueryPrefix)
+}
+
+var (
+        md5Pool    = sync.Pool{New: func() interface{} { return md5.New() }}
+        sha256Pool = sync.Pool{New: func() interface{} { return sha256.New() }}
+)
+
+func newMd5Hasher() md5simd.Hasher {
+        return &hashWrapper{Hash: md5Pool.Get().(hash.Hash), isMD5: true}
+}
+
+func newSHA256Hasher() md5simd.Hasher {
+        if encrypt.FIPS {
+                return &hashWrapper{Hash: fipssha256.New(), isSHA256: true}
+        }
+        return &hashWrapper{Hash: sha256Pool.Get().(hash.Hash), isSHA256: true}
+}
+
+// hashWrapper implements the md5simd.Hasher interface.
+type hashWrapper struct {
+        hash.Hash
+        isMD5    bool
+        isSHA256 bool
+}
+
+// Close will put the hasher back into the pool.
+func (m *hashWrapper) Close() {
+        if m.isMD5 && m.Hash != nil {
+                m.Reset()
+                md5Pool.Put(m.Hash)
+        }
+        if m.isSHA256 && m.Hash != nil {
+                m.Reset()
+                sha256Pool.Put(m.Hash)
+        }
+        m.Hash = nil
+}
+
+const letterBytes = "abcdefghijklmnopqrstuvwxyz01234569"
+const (
+        letterIdxBits = 6                    // 6 bits to represent a letter index
+        letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
+        letterIdxMax  = 63 / letterIdxBits   // # of letter indices fitting in 63 bits
+)
+
+// randString generates random names and prepends them with a known prefix.
+func randString(n int, src rand.Source, prefix string) string {
+        b := make([]byte, n)
+        // A rand.Int63() generates 63 random bits, enough for letterIdxMax letters!
+        for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
+                if remain == 0 {
+                        cache, remain = src.Int63(), letterIdxMax
+                }
+                if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
+                        b[i] = letterBytes[idx]
+                        i--
+                }
+                cache >>= letterIdxBits
+                remain--
+        }
+        return prefix + string(b[0:30-len(prefix)])
+}
+
+// IsNetworkOrHostDown - if there was a network error or if the host is down.
+// expectTimeouts indicates that *context* timeouts are expected and does not
+// indicate a downed host. Other timeouts still returns down.
+func IsNetworkOrHostDown(err error, expectTimeouts bool) bool {
+        if err == nil {
+                return false
+        }
+
+        if errors.Is(err, context.Canceled) {
+                return false
+        }
+
+        if expectTimeouts && errors.Is(err, context.DeadlineExceeded) {
+                return false
+        }
+
+        if errors.Is(err, context.DeadlineExceeded) {
+                return true
+        }
+
+        // We need to figure if the error either a timeout
+        // or a non-temporary error.
+        urlErr := &url.Error{}
+        if errors.As(err, &urlErr) {
+                switch urlErr.Err.(type) {
+                case *net.DNSError, *net.OpError, net.UnknownNetworkError:
+                        return true
+                }
+        }
+        var e net.Error
+        if errors.As(err, &e) {
+                if e.Timeout() {
+                        return true
+                }
+        }
+
+        // Fallback to other mechanisms.
+        switch {
+        case strings.Contains(err.Error(), "Connection closed by foreign host"):
+                return true
+        case strings.Contains(err.Error(), "TLS handshake timeout"):
+                // If error is - tlsHandshakeTimeoutError.
+                return true
+        case strings.Contains(err.Error(), "i/o timeout"):
+                // If error is - tcp timeoutError.
+                return true
+        case strings.Contains(err.Error(), "connection timed out"):
+                // If err is a net.Dial timeout.
+                return true
+        case strings.Contains(err.Error(), "connection refused"):
+                // If err is connection refused
+                return true
+
+        case strings.Contains(strings.ToLower(err.Error()), "503 service unavailable"):
+                // Denial errors
+                return true
+        }
+        return false
+}
+
+// newHashReaderWrapper will hash all reads done through r.
+// When r returns io.EOF the done function will be called with the sum.
+func newHashReaderWrapper(r io.Reader, h hash.Hash, done func(hash []byte)) *hashReaderWrapper {
+        return &hashReaderWrapper{
+                r:    r,
+                h:    h,
+                done: done,
+        }
+}
+
+type hashReaderWrapper struct {
+        r    io.Reader
+        h    hash.Hash
+        done func(hash []byte)
+}
+
+// Read implements the io.Reader interface.
+func (h *hashReaderWrapper) Read(p []byte) (n int, err error) {
+        n, err = h.r.Read(p)
+        if n > 0 {
+                n2, err := h.h.Write(p[:n])
+                if err != nil {
+                        return 0, err
+                }
+                if n2 != n {
+                        return 0, io.ErrShortWrite
+                }
+        }
+        if err == io.EOF {
+                // Call back
+                h.done(h.h.Sum(nil))
+        }
+        return n, err
+}
diff --git a/vendor/github.com/minio/sha256-simd/.gitignore b/vendor/github.com/minio/sha256-simd/.gitignore
new file mode 100644
index 0000000..c56069f
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/.gitignore
@@ -0,0 +1 @@
+*.test
\ No newline at end of file
diff --git a/vendor/github.com/minio/sha256-simd/LICENSE b/vendor/github.com/minio/sha256-simd/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/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.
diff --git a/vendor/github.com/minio/sha256-simd/README.md b/vendor/github.com/minio/sha256-simd/README.md
new file mode 100644
index 0000000..6117488
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/README.md
@@ -0,0 +1,137 @@
+# sha256-simd
+
+Accelerate SHA256 computations in pure Go using AVX512, SHA Extensions for x86 and ARM64 for ARM. 
+On AVX512 it provides an up to 8x improvement (over 3 GB/s per core).
+SHA Extensions give a performance boost of close to 4x over native.
+
+## Introduction
+
+This package is designed as a replacement for `crypto/sha256`. 
+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.
+
+## 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 |
+
+## 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.
diff --git a/vendor/github.com/minio/sha256-simd/cpuid_other.go b/vendor/github.com/minio/sha256-simd/cpuid_other.go
new file mode 100644
index 0000000..97af6a1
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/cpuid_other.go
@@ -0,0 +1,50 @@
+// Minio Cloud Storage, (C) 2021 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"
+        "runtime"
+
+        "github.com/klauspost/cpuid/v2"
+)
+
+var (
+        hasIntelSha = runtime.GOARCH == "amd64" && cpuid.CPU.Supports(cpuid.SHA, cpuid.SSSE3, cpuid.SSE4)
+        hasAvx512   = cpuid.CPU.Supports(cpuid.AVX512F, cpuid.AVX512DQ, cpuid.AVX512BW, cpuid.AVX512VL)
+)
+
+func hasArmSha2() bool {
+        if cpuid.CPU.Has(cpuid.SHA2) {
+                return true
+        }
+        if runtime.GOARCH != "arm64" || runtime.GOOS != "linux" {
+                return false
+        }
+
+        // Fall back to hacky cpuinfo parsing...
+        const procCPUInfo = "/proc/cpuinfo"
+
+        // Feature to check for.
+        const sha256Feature = "sha2"
+
+        cpuInfo, err := ioutil.ReadFile(procCPUInfo)
+        if err != nil {
+                return false
+        }
+        return bytes.Contains(cpuInfo, []byte(sha256Feature))
+}
diff --git a/vendor/github.com/minio/sha256-simd/sha256.go b/vendor/github.com/minio/sha256-simd/sha256.go
new file mode 100644
index 0000000..f146bbd
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256.go
@@ -0,0 +1,468 @@
+/*
+ * 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"
+        "errors"
+        "hash"
+)
+
+// 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 (
+        blockfuncStdlib blockfuncType = iota
+        blockfuncIntelSha
+        blockfuncArmSha2
+        blockfuncForceGeneric = -1
+)
+
+var blockfunc blockfuncType
+
+func init() {
+        switch {
+        case hasIntelSha:
+                blockfunc = blockfuncIntelSha
+        case hasArmSha2():
+                blockfunc = blockfuncArmSha2
+        }
+}
+
+// New returns a new hash.Hash computing the SHA256 checksum.
+func New() hash.Hash {
+        if blockfunc == blockfuncStdlib {
+                // Fallback to the standard golang implementation
+                // if no features were found.
+                return sha256.New()
+        }
+
+        d := new(digest)
+        d.Reset()
+        return d
+}
+
+// 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
+}
+
+func block(dig *digest, p []byte) {
+        if blockfunc == blockfuncIntelSha {
+                blockIntelShaGo(dig, p)
+        } else if blockfunc == blockfuncArmSha2 {
+                blockArmSha2Go(dig, p)
+        } else {
+                blockGeneric(dig, p)
+        }
+}
+
+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,
+}
+
+const (
+        magic256      = "sha\x03"
+        marshaledSize = len(magic256) + 8*4 + chunk + 8
+)
+
+func (d *digest) MarshalBinary() ([]byte, error) {
+        b := make([]byte, 0, marshaledSize)
+        b = append(b, magic256...)
+        b = appendUint32(b, d.h[0])
+        b = appendUint32(b, d.h[1])
+        b = appendUint32(b, d.h[2])
+        b = appendUint32(b, d.h[3])
+        b = appendUint32(b, d.h[4])
+        b = appendUint32(b, d.h[5])
+        b = appendUint32(b, d.h[6])
+        b = appendUint32(b, d.h[7])
+        b = append(b, d.x[:d.nx]...)
+        b = b[:len(b)+len(d.x)-d.nx] // already zero
+        b = appendUint64(b, d.len)
+        return b, nil
+}
+
+func (d *digest) UnmarshalBinary(b []byte) error {
+        if len(b) < len(magic256) || string(b[:len(magic256)]) != magic256 {
+                return errors.New("crypto/sha256: invalid hash state identifier")
+        }
+        if len(b) != marshaledSize {
+                return errors.New("crypto/sha256: invalid hash state size")
+        }
+        b = b[len(magic256):]
+        b, d.h[0] = consumeUint32(b)
+        b, d.h[1] = consumeUint32(b)
+        b, d.h[2] = consumeUint32(b)
+        b, d.h[3] = consumeUint32(b)
+        b, d.h[4] = consumeUint32(b)
+        b, d.h[5] = consumeUint32(b)
+        b, d.h[6] = consumeUint32(b)
+        b, d.h[7] = consumeUint32(b)
+        b = b[copy(d.x[:], b):]
+        b, d.len = consumeUint64(b)
+        d.nx = int(d.len % chunk)
+        return nil
+}
+
+func appendUint32(b []byte, v uint32) []byte {
+        return append(b,
+                byte(v>>24),
+                byte(v>>16),
+                byte(v>>8),
+                byte(v),
+        )
+}
+
+func appendUint64(b []byte, v uint64) []byte {
+        return append(b,
+                byte(v>>56),
+                byte(v>>48),
+                byte(v>>40),
+                byte(v>>32),
+                byte(v>>24),
+                byte(v>>16),
+                byte(v>>8),
+                byte(v),
+        )
+}
+
+func consumeUint64(b []byte) ([]byte, uint64) {
+        _ = b[7]
+        x := uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |
+                uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56
+        return b[8:], x
+}
+
+func consumeUint32(b []byte) ([]byte, uint32) {
+        _ = b[3]
+        x := uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
+        return b[4:], x
+}
diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.asm b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.asm
new file mode 100644
index 0000000..c959b1a
--- /dev/null
+++ b/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
diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.go b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.go
new file mode 100644
index 0000000..4b9473a
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.go
@@ -0,0 +1,501 @@
+//go:build !noasm && !appengine && gc
+// +build !noasm,!appengine,gc
+
+/*
+ * 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)
+        trail = append(trail, d.x[:d.nx]...)
+
+        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(trail, tmp[0:56-len%64]...)
+        } else {
+                trail = append(trail, 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() {
+
+        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
+                }
+        }
+}
+
+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
+}
diff --git a/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.s b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.s
new file mode 100644
index 0000000..cca534e
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256blockAvx512_amd64.s
@@ -0,0 +1,267 @@
+//+build !noasm,!appengine,gc
+
+TEXT ·sha256X16Avx512(SB), 7, $0
+        MOVQ  digests+0(FP), DI
+        MOVQ  scratch+8(FP), R12
+        MOVQ  mask_len+32(FP), SI
+        MOVQ  mask_base+24(FP), R13
+        MOVQ  (R13), R14
+        LONG  $0x92fbc1c4; BYTE $0xce
+        LEAQ  inputs+48(FP), AX
+        QUAD  $0xf162076f487ef162; QUAD $0x7ef162014f6f487e; QUAD $0x487ef16202576f48; QUAD $0x6f487ef162035f6f; QUAD $0x6f6f487ef1620467; QUAD $0x06776f487ef16205; LONG $0x487ef162; WORD $0x7f6f; BYTE $0x07
+        MOVQ  table+16(FP), DX
+        WORD  $0x3148; BYTE $0xc9
+        TESTQ $(1<<0), R14
+        JE    skipInput0
+        MOVQ  0*24(AX), R9
+        LONG  $0x487cc162; WORD $0x0410; BYTE $0x09
+
+skipInput0:
+        TESTQ $(1<<1), R14
+        JE    skipInput1
+        MOVQ  1*24(AX), R9
+        LONG  $0x487cc162; WORD $0x0c10; BYTE $0x09
+
+skipInput1:
+        TESTQ $(1<<2), R14
+        JE    skipInput2
+        MOVQ  2*24(AX), R9
+        LONG  $0x487cc162; WORD $0x1410; BYTE $0x09
+
+skipInput2:
+        TESTQ $(1<<3), R14
+        JE    skipInput3
+        MOVQ  3*24(AX), R9
+        LONG  $0x487cc162; WORD $0x1c10; BYTE $0x09
+
+skipInput3:
+        TESTQ $(1<<4), R14
+        JE    skipInput4
+        MOVQ  4*24(AX), R9
+        LONG  $0x487cc162; WORD $0x2410; BYTE $0x09
+
+skipInput4:
+        TESTQ $(1<<5), R14
+        JE    skipInput5
+        MOVQ  5*24(AX), R9
+        LONG  $0x487cc162; WORD $0x2c10; BYTE $0x09
+
+skipInput5:
+        TESTQ $(1<<6), R14
+        JE    skipInput6
+        MOVQ  6*24(AX), R9
+        LONG  $0x487cc162; WORD $0x3410; BYTE $0x09
+
+skipInput6:
+        TESTQ $(1<<7), R14
+        JE    skipInput7
+        MOVQ  7*24(AX), R9
+        LONG  $0x487cc162; WORD $0x3c10; BYTE $0x09
+
+skipInput7:
+        TESTQ $(1<<8), R14
+        JE    skipInput8
+        MOVQ  8*24(AX), R9
+        LONG  $0x487c4162; WORD $0x0410; BYTE $0x09
+
+skipInput8:
+        TESTQ $(1<<9), R14
+        JE    skipInput9
+        MOVQ  9*24(AX), R9
+        LONG  $0x487c4162; WORD $0x0c10; BYTE $0x09
+
+skipInput9:
+        TESTQ $(1<<10), R14
+        JE    skipInput10
+        MOVQ  10*24(AX), R9
+        LONG  $0x487c4162; WORD $0x1410; BYTE $0x09
+
+skipInput10:
+        TESTQ $(1<<11), R14
+        JE    skipInput11
+        MOVQ  11*24(AX), R9
+        LONG  $0x487c4162; WORD $0x1c10; BYTE $0x09
+
+skipInput11:
+        TESTQ $(1<<12), R14
+        JE    skipInput12
+        MOVQ  12*24(AX), R9
+        LONG  $0x487c4162; WORD $0x2410; BYTE $0x09
+
+skipInput12:
+        TESTQ $(1<<13), R14
+        JE    skipInput13
+        MOVQ  13*24(AX), R9
+        LONG  $0x487c4162; WORD $0x2c10; BYTE $0x09
+
+skipInput13:
+        TESTQ $(1<<14), R14
+        JE    skipInput14
+        MOVQ  14*24(AX), R9
+        LONG  $0x487c4162; WORD $0x3410; BYTE $0x09
+
+skipInput14:
+        TESTQ $(1<<15), R14
+        JE    skipInput15
+        MOVQ  15*24(AX), R9
+        LONG  $0x487c4162; WORD $0x3c10; BYTE $0x09
+
+skipInput15:
+lloop:
+        LEAQ                 PSHUFFLE_BYTE_FLIP_MASK<>(SB), DX
+        LONG                 $0x487e7162; WORD $0x1a6f
+        MOVQ                 table+16(FP), DX
+        QUAD                 $0xd162226f487e7162; QUAD $0x7ed16224047f487e; QUAD $0x7ed16201244c7f48; QUAD $0x7ed1620224547f48; QUAD $0x7ed16203245c7f48; QUAD $0x7ed1620424647f48; QUAD $0x7ed16205246c7f48; QUAD $0x7ed1620624747f48; QUAD $0xc1834807247c7f48; QUAD $0x44c9c6407c316240; QUAD $0x62eec1c6407ca162; QUAD $0xa16244d3c6406c31; QUAD $0x34c162eed3c6406c; QUAD $0x407ca162dddac648; QUAD $0xc6407ca16288cac6; QUAD $0xcac648345162ddc2; QUAD $0x44d5c6405ca16288; QUAD $0x62eee5c6405ca162; QUAD $0xa16244d7c6404c31; QUAD $0x6cc162eef7c6404c; QUAD $0x405ca162ddfac640; QUAD $0xc6405ca16288eec6; QUAD $0xd2c6406cc162dde6; QUAD $0x44f1c6403c816288; QUAD $0x62eec1c6403c0162; QUAD $0x016244d3c6402c11; QUAD $0x4c4162eed3c6402c; QUAD $0x403c0162dddac640; QUAD $0xc6403c016288cac6; QUAD $0xf2c6404cc162ddc2; QUAD $0x44d5c6401c016288; QUAD $0x62eee5c6401c0162; QUAD $0x016244d7c6400c11; QUAD $0x2c4162eef7c6400c; QUAD $0x401c0162ddfac640; QUAD $0xc6401c016288eec6; QUAD $0xd2c6402c4162dde6; BYTE $0x88
+        LEAQ                 PSHUFFLE_TRANSPOSE16_MASK1<>(SB), BX
+        LEAQ                 PSHUFFLE_TRANSPOSE16_MASK2<>(SB), R8
+        QUAD                 $0x2262336f487e6162; QUAD $0x487e5162f27648b5; QUAD $0xd27648b53262106f; QUAD $0xa262136f487ee162; QUAD $0x487e5162d77640e5; QUAD $0xcf7640e53262086f; QUAD $0xa2621b6f487ee162; QUAD $0x487ec162dd7640f5; QUAD $0xfd7640f5a262386f; QUAD $0xa2620b6f487ee162; QUAD $0x487ec162cc7640fd; QUAD $0xec7640fda262286f; QUAD $0x8262036f487ee162; QUAD $0x487ec162c27640cd; QUAD $0xe27640cd8262206f; QUAD $0x8262336f487ee162; QUAD $0x487e4162f77640a5; QUAD $0xd77640a50262106f; QUAD $0x02621b6f487e6162; QUAD $0x487e4162dd7640b5; QUAD $0xfd7640b50262386f; QUAD $0x02620b6f487e6162; QUAD $0x487e4162cc7640bd; QUAD $0xec7640bd0262286f; QUAD $0x62eec023408d2362; QUAD $0x236244c023408da3; QUAD $0xada362eee42348ad; QUAD $0x40c5036244e42348; QUAD $0x2340c51362eef723; QUAD $0xfd2340d5036244d7; QUAD $0x44fd2340d58362ee; QUAD $0x62eeea2348b50362; QUAD $0x036244ea2348b583; QUAD $0xe51362eed32340e5; QUAD $0x40f5036244cb2340; QUAD $0x2340f58362eed923; QUAD $0xce2340ed236244d9; QUAD $0x44ce2340eda362ee; QUAD $0xc162d16f487ec162; QUAD $0x407dc262f26f487e; QUAD $0xcb004075c262c300; QUAD $0xc262d300406dc262; QUAD $0x405dc262db004065; QUAD $0xeb004055c262e300; QUAD $0xc262f300404dc262; QUAD $0x403d4262fb004045; QUAD $0xcb0040354262c300; QUAD $0x4262d300402d4262; QUAD $0x401d4262db004025; QUAD $0xeb0040154262e300; QUAD $0x4262f300400d4262; QUAD $0x48455162fb004005; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d3162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6201626f487e7162; QUAD $0x916211c672481591; QUAD $0x05916213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe407dc16296ef25; QUAD $0x62c1fe407d8162c5; QUAD $0xb16207c1724815b1; QUAD $0x05b16212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe407dc16296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d3162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815916202626f48; QUAD $0x72480d916211c772; QUAD $0xd7724805916213c7; QUAD $0x96ef25480d53620a; QUAD $0x8162cdfe4075c162; QUAD $0x4815b162cafe4075; QUAD $0x72480db16207c272; QUAD $0xd2724805b16212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe4075c162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x3162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c0724815b16203; QUAD $0x6213c072480db162; QUAD $0x53620ad0724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe406d8162d5fe40; QUAD $0x07c3724815b162d3; QUAD $0x6212c372480db162; QUAD $0x536203d3724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d3162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0xb16204626f487e71; QUAD $0x0db16211c1724815; QUAD $0x4805b16213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4065c16296ef; QUAD $0xb162dcfe40658162; QUAD $0x0db16207c4724815; QUAD $0x4805b16212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4065c16296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x724815b16205626f; QUAD $0xc272480db16211c2; QUAD $0x0ad2724805b16213; QUAD $0x6296ef25480d5362; QUAD $0x5d8162e5fe405dc1; QUAD $0x724815b162e5fe40; QUAD $0xc572480db16207c5; QUAD $0x03d5724805b16212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe405dc1; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d3162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x06626f487e7162d0; QUAD $0x6211c3724815b162; QUAD $0xb16213c372480db1; QUAD $0x0d53620ad3724805; QUAD $0x4055c16296ef2548; QUAD $0xeefe40558162edfe; QUAD $0x6207c6724815b162; QUAD $0xb16212c672480db1; QUAD $0x0d536203d6724805; QUAD $0x4055c16296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d3162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x15b16207626f487e; QUAD $0x480db16211c47248; QUAD $0x724805b16213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe404dc16296; QUAD $0x15b162f7fe404d81; QUAD $0x480db16207c77248; QUAD $0x724805b16212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe404dc16296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d31; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc5724815b1620862; QUAD $0x13c572480db16211; QUAD $0x620ad5724805b162; QUAD $0xc16296ef25480d53; QUAD $0x4045a162fdfe4045; QUAD $0xc07248159162f8fe; QUAD $0x12c072480d916207; QUAD $0x6203d07248059162; QUAD $0xc16296ef25480d53; QUAD $0x48455162fdfe4045; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d1162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6209626f487e7162; QUAD $0xb16211c6724815b1; QUAD $0x05b16213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe403d416296ef25; QUAD $0x62c1fe403d2162c5; QUAD $0x916207c172481591; QUAD $0x05916212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe403d416296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d1162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815b1620a626f48; QUAD $0x72480db16211c772; QUAD $0xd7724805b16213c7; QUAD $0x96ef25480d53620a; QUAD $0x2162cdfe40354162; QUAD $0x48159162cafe4035; QUAD $0x72480d916207c272; QUAD $0xd2724805916212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe40354162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x1162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c072481591620b; QUAD $0x6213c072480d9162; QUAD $0x53620ad072480591; QUAD $0x2d416296ef25480d; QUAD $0xfe402d2162d5fe40; QUAD $0x07c37248159162d3; QUAD $0x6212c372480d9162; QUAD $0x536203d372480591; QUAD $0x2d416296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d1162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0x91620c626f487e71; QUAD $0x0d916211c1724815; QUAD $0x4805916213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4025416296ef; QUAD $0x9162dcfe40252162; QUAD $0x0d916207c4724815; QUAD $0x4805916212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4025416296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x72481591620d626f; QUAD $0xc272480d916211c2; QUAD $0x0ad2724805916213; QUAD $0x6296ef25480d5362; QUAD $0x1d2162e5fe401d41; QUAD $0x7248159162e5fe40; QUAD $0xc572480d916207c5; QUAD $0x03d5724805916212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe401d41; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d1162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x0e626f487e7162d0; QUAD $0x6211c37248159162; QUAD $0x916213c372480d91; QUAD $0x0d53620ad3724805; QUAD $0x4015416296ef2548; QUAD $0xeefe40152162edfe; QUAD $0x6207c67248159162; QUAD $0x916212c672480d91; QUAD $0x0d536203d6724805; QUAD $0x4015416296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d1162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x1591620f626f487e; QUAD $0x480d916211c47248; QUAD $0x724805916213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe400d416296; QUAD $0x159162f7fe400d21; QUAD $0x480d916207c77248; QUAD $0x724805916212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe400d416296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d11; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc572481591621062; QUAD $0x13c572480d916211; QUAD $0x620ad57248059162; QUAD $0x416296ef25480d53; QUAD $0x40050162fdfe4005; QUAD $0xc0724815b162f8fe; QUAD $0x12c072480db16207; QUAD $0x6203d0724805b162; QUAD $0x416296ef25480d53; QUAD $0x48455162fdfe4005; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d3162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6211626f487e7162; QUAD $0x916211c672481591; QUAD $0x05916213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe407dc16296ef25; QUAD $0x62c1fe407d8162c5; QUAD $0xb16207c1724815b1; QUAD $0x05b16212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe407dc16296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d3162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815916212626f48; QUAD $0x72480d916211c772; QUAD $0xd7724805916213c7; QUAD $0x96ef25480d53620a; QUAD $0x8162cdfe4075c162; QUAD $0x4815b162cafe4075; QUAD $0x72480db16207c272; QUAD $0xd2724805b16212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe4075c162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x3162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c0724815b16213; QUAD $0x6213c072480db162; QUAD $0x53620ad0724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe406d8162d5fe40; QUAD $0x07c3724815b162d3; QUAD $0x6212c372480db162; QUAD $0x536203d3724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d3162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0xb16214626f487e71; QUAD $0x0db16211c1724815; QUAD $0x4805b16213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4065c16296ef; QUAD $0xb162dcfe40658162; QUAD $0x0db16207c4724815; QUAD $0x4805b16212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4065c16296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x724815b16215626f; QUAD $0xc272480db16211c2; QUAD $0x0ad2724805b16213; QUAD $0x6296ef25480d5362; QUAD $0x5d8162e5fe405dc1; QUAD $0x724815b162e5fe40; QUAD $0xc572480db16207c5; QUAD $0x03d5724805b16212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe405dc1; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d3162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x16626f487e7162d0; QUAD $0x6211c3724815b162; QUAD $0xb16213c372480db1; QUAD $0x0d53620ad3724805; QUAD $0x4055c16296ef2548; QUAD $0xeefe40558162edfe; QUAD $0x6207c6724815b162; QUAD $0xb16212c672480db1; QUAD $0x0d536203d6724805; QUAD $0x4055c16296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d3162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x15b16217626f487e; QUAD $0x480db16211c47248; QUAD $0x724805b16213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe404dc16296; QUAD $0x15b162f7fe404d81; QUAD $0x480db16207c77248; QUAD $0x724805b16212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe404dc16296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d31; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc5724815b1621862; QUAD $0x13c572480db16211; QUAD $0x620ad5724805b162; QUAD $0xc16296ef25480d53; QUAD $0x4045a162fdfe4045; QUAD $0xc07248159162f8fe; QUAD $0x12c072480d916207; QUAD $0x6203d07248059162; QUAD $0xc16296ef25480d53; QUAD $0x48455162fdfe4045; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d1162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6219626f487e7162; QUAD $0xb16211c6724815b1; QUAD $0x05b16213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe403d416296ef25; QUAD $0x62c1fe403d2162c5; QUAD $0x916207c172481591; QUAD $0x05916212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe403d416296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d1162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815b1621a626f48; QUAD $0x72480db16211c772; QUAD $0xd7724805b16213c7; QUAD $0x96ef25480d53620a; QUAD $0x2162cdfe40354162; QUAD $0x48159162cafe4035; QUAD $0x72480d916207c272; QUAD $0xd2724805916212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe40354162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x1162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c072481591621b; QUAD $0x6213c072480d9162; QUAD $0x53620ad072480591; QUAD $0x2d416296ef25480d; QUAD $0xfe402d2162d5fe40; QUAD $0x07c37248159162d3; QUAD $0x6212c372480d9162; QUAD $0x536203d372480591; QUAD $0x2d416296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d1162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0x91621c626f487e71; QUAD $0x0d916211c1724815; QUAD $0x4805916213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4025416296ef; QUAD $0x9162dcfe40252162; QUAD $0x0d916207c4724815; QUAD $0x4805916212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4025416296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x72481591621d626f; QUAD $0xc272480d916211c2; QUAD $0x0ad2724805916213; QUAD $0x6296ef25480d5362; QUAD $0x1d2162e5fe401d41; QUAD $0x7248159162e5fe40; QUAD $0xc572480d916207c5; QUAD $0x03d5724805916212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe401d41; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d1162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x1e626f487e7162d0; QUAD $0x6211c37248159162; QUAD $0x916213c372480d91; QUAD $0x0d53620ad3724805; QUAD $0x4015416296ef2548; QUAD $0xeefe40152162edfe; QUAD $0x6207c67248159162; QUAD $0x916212c672480d91; QUAD $0x0d536203d6724805; QUAD $0x4015416296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d1162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x1591621f626f487e; QUAD $0x480d916211c47248; QUAD $0x724805916213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe400d416296; QUAD $0x159162f7fe400d21; QUAD $0x480d916207c77248; QUAD $0x724805916212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe400d416296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d11; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc572481591622062; QUAD $0x13c572480d916211; QUAD $0x620ad57248059162; QUAD $0x416296ef25480d53; QUAD $0x40050162fdfe4005; QUAD $0xc0724815b162f8fe; QUAD $0x12c072480db16207; QUAD $0x6203d0724805b162; QUAD $0x416296ef25480d53; QUAD $0x48455162fdfe4005; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d3162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6221626f487e7162; QUAD $0x916211c672481591; QUAD $0x05916213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe407dc16296ef25; QUAD $0x62c1fe407d8162c5; QUAD $0xb16207c1724815b1; QUAD $0x05b16212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe407dc16296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d3162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815916222626f48; QUAD $0x72480d916211c772; QUAD $0xd7724805916213c7; QUAD $0x96ef25480d53620a; QUAD $0x8162cdfe4075c162; QUAD $0x4815b162cafe4075; QUAD $0x72480db16207c272; QUAD $0xd2724805b16212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe4075c162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x3162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c0724815b16223; QUAD $0x6213c072480db162; QUAD $0x53620ad0724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe406d8162d5fe40; QUAD $0x07c3724815b162d3; QUAD $0x6212c372480db162; QUAD $0x536203d3724805b1; QUAD $0x6dc16296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d3162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0xb16224626f487e71; QUAD $0x0db16211c1724815; QUAD $0x4805b16213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4065c16296ef; QUAD $0xb162dcfe40658162; QUAD $0x0db16207c4724815; QUAD $0x4805b16212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4065c16296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x724815b16225626f; QUAD $0xc272480db16211c2; QUAD $0x0ad2724805b16213; QUAD $0x6296ef25480d5362; QUAD $0x5d8162e5fe405dc1; QUAD $0x724815b162e5fe40; QUAD $0xc572480db16207c5; QUAD $0x03d5724805b16212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe405dc1; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d3162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x26626f487e7162d0; QUAD $0x6211c3724815b162; QUAD $0xb16213c372480db1; QUAD $0x0d53620ad3724805; QUAD $0x4055c16296ef2548; QUAD $0xeefe40558162edfe; QUAD $0x6207c6724815b162; QUAD $0xb16212c672480db1; QUAD $0x0d536203d6724805; QUAD $0x4055c16296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d3162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x15b16227626f487e; QUAD $0x480db16211c47248; QUAD $0x724805b16213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe404dc16296; QUAD $0x15b162f7fe404d81; QUAD $0x480db16207c77248; QUAD $0x724805b16212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe404dc16296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d31; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc5724815b1622862; QUAD $0x13c572480db16211; QUAD $0x620ad5724805b162; QUAD $0xc16296ef25480d53; QUAD $0x4045a162fdfe4045; QUAD $0xc07248159162f8fe; QUAD $0x12c072480d916207; QUAD $0x6203d07248059162; QUAD $0xc16296ef25480d53; QUAD $0x48455162fdfe4045; QUAD $0xcc6f487e7162c4fe; QUAD $0x6206c472482df162; QUAD $0xf1620bc4724825f1; QUAD $0x55736219c472481d; QUAD $0x483d1162cace2548; QUAD $0xd42548255362c0fe; QUAD $0x62c1fe483d516296; QUAD $0x65d162c2fe483d51; QUAD $0x724845f162d8fe48; QUAD $0xc0724825f16202c0; QUAD $0x16c072481df1620d; QUAD $0x7362c86f487e7162; QUAD $0x25d362e8ca254875; QUAD $0x4845d16296fc2548; QUAD $0xf8fe4845d162f9fe; QUAD $0x6229626f487e7162; QUAD $0xb16211c6724815b1; QUAD $0x05b16213c672480d; QUAD $0x480d53620ad67248; QUAD $0xfe403d416296ef25; QUAD $0x62c1fe403d2162c5; QUAD $0x916207c172481591; QUAD $0x05916212c172480d; QUAD $0x480d536203d17248; QUAD $0xfe403d416296ef25; QUAD $0x62c4fe484d5162c5; QUAD $0x2df162cb6f487e71; QUAD $0x4825f16206c37248; QUAD $0x72481df1620bc372; QUAD $0xcd25485d736219c3; QUAD $0x62c1fe483d1162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xd0fe486dd162c2fe; QUAD $0x6202c772484df162; QUAD $0xf1620dc7724825f1; QUAD $0x7e716216c772481d; QUAD $0x25487d7362cf6f48; QUAD $0xf4254825d362e8c9; QUAD $0x62f1fe484dd16296; QUAD $0x7e7162f0fe484dd1; QUAD $0x4815b1622a626f48; QUAD $0x72480db16211c772; QUAD $0xd7724805b16213c7; QUAD $0x96ef25480d53620a; QUAD $0x2162cdfe40354162; QUAD $0x48159162cafe4035; QUAD $0x72480d916207c272; QUAD $0xd2724805916212c2; QUAD $0x96ef25480d536203; QUAD $0x5162cdfe40354162; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x1162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x11c072481591622b; QUAD $0x6213c072480d9162; QUAD $0x53620ad072480591; QUAD $0x2d416296ef25480d; QUAD $0xfe402d2162d5fe40; QUAD $0x07c37248159162d3; QUAD $0x6212c372480d9162; QUAD $0x536203d372480591; QUAD $0x2d416296ef25480d; QUAD $0xfe485d5162d5fe40; QUAD $0x62c96f487e7162c4; QUAD $0xf16206c172482df1; QUAD $0x1df1620bc1724825; QUAD $0x486d736219c17248; QUAD $0xfe483d1162cacb25; QUAD $0x96d42548255362c3; QUAD $0x5162c1fe483d5162; QUAD $0x487dd162c2fe483d; QUAD $0xc572485df162c0fe; QUAD $0x0dc5724825f16202; QUAD $0x6216c572481df162; QUAD $0x4d7362cd6f487e71; QUAD $0x4825d362e8cf2548; QUAD $0xfe485dd16296e425; QUAD $0x62e0fe485dd162e1; QUAD $0x91622c626f487e71; QUAD $0x0d916211c1724815; QUAD $0x4805916213c17248; QUAD $0x25480d53620ad172; QUAD $0xddfe4025416296ef; QUAD $0x9162dcfe40252162; QUAD $0x0d916207c4724815; QUAD $0x4805916212c47248; QUAD $0x25480d536203d472; QUAD $0xddfe4025416296ef; QUAD $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; QUAD $0x72481591622d626f; QUAD $0xc272480d916211c2; QUAD $0x0ad2724805916213; QUAD $0x6296ef25480d5362; QUAD $0x1d2162e5fe401d41; QUAD $0x7248159162e5fe40; QUAD $0xc572480d916207c5; QUAD $0x03d5724805916212; QUAD $0x6296ef25480d5362; QUAD $0x6d5162e5fe401d41; QUAD $0x6f487e7162c4fe48; QUAD $0x06c772482df162cf; QUAD $0x620bc7724825f162; QUAD $0x736219c772481df1; QUAD $0x3d1162cac925487d; QUAD $0x2548255362c5fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x486df162f0fe484d; QUAD $0x724825f16202c372; QUAD $0xc372481df1620dc3; QUAD $0x62cb6f487e716216; QUAD $0xd362e8cd25485d73; QUAD $0x6dd16296d4254825; QUAD $0xfe486dd162d1fe48; QUAD $0x2e626f487e7162d0; QUAD $0x6211c37248159162; QUAD $0x916213c372480d91; QUAD $0x0d53620ad3724805; QUAD $0x4015416296ef2548; QUAD $0xeefe40152162edfe; QUAD $0x6207c67248159162; QUAD $0x916212c672480d91; QUAD $0x0d536203d6724805; QUAD $0x4015416296ef2548; QUAD $0xc4fe48755162edfe; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d1162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x1591622f626f487e; QUAD $0x480d916211c47248; QUAD $0x724805916213c472; QUAD $0xef25480d53620ad4; QUAD $0x62f5fe400d416296; QUAD $0x159162f7fe400d21; QUAD $0x480d916207c77248; QUAD $0x724805916212c772; QUAD $0xef25480d536203d7; QUAD $0x62f5fe400d416296; QUAD $0x7e7162c4fe487d51; QUAD $0x72482df162cd6f48; QUAD $0xc5724825f16206c5; QUAD $0x19c572481df1620b; QUAD $0x62cacf25484d7362; QUAD $0x255362c7fe483d11; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162e0fe485dd162; QUAD $0x25f16202c172487d; QUAD $0x481df1620dc17248; QUAD $0x6f487e716216c172; QUAD $0xe8cb25486d7362c9; QUAD $0x6296c4254825d362; QUAD $0x7dd162c1fe487dd1; QUAD $0x6f487e7162c0fe48; QUAD $0xc572481591623062; QUAD $0x13c572480d916211; QUAD $0x620ad57248059162; QUAD $0x416296ef25480d53; QUAD $0x40050162fdfe4005; QUAD $0xc0724815b162f8fe; QUAD $0x12c072480db16207; QUAD $0x6203d0724805b162; QUAD $0x416296ef25480d53; QUAD $0x01ee8348fdfe4005
+        JE                   lastLoop
+        ADDQ                 $8, R13
+        MOVQ                 (R13), R14
+        QUAD                 $0x7162c4fe48455162; QUAD $0x482df162cc6f487e; QUAD $0x724825f16206c472; QUAD $0xc472481df1620bc4; QUAD $0xcace254855736219; QUAD $0x5362c0fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d8fe4865d162c2; QUAD $0xf16202c0724845f1; QUAD $0x1df1620dc0724825; QUAD $0x487e716216c07248; QUAD $0xca2548757362c86f; QUAD $0x96fc254825d362e8; QUAD $0xd162f9fe4845d162; QUAD $0x487e7162f8fe4845; WORD $0x626f; BYTE $0x31
+        TESTQ                $(1<<0), R14
+        JE                   skipNext0
+        MOVQ                 0*24(AX), R9
+        LONG                 $0x487cc162; WORD $0x0410; BYTE $0x09
+
+skipNext0:
+        QUAD  $0x7162c4fe484d5162; QUAD $0x482df162cb6f487e; QUAD $0x724825f16206c372; QUAD $0xc372481df1620bc3; QUAD $0xcacd25485d736219; QUAD $0x5362c1fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d0fe486dd162c2; QUAD $0xf16202c772484df1; QUAD $0x1df1620dc7724825; QUAD $0x487e716216c77248; QUAD $0xc925487d7362cf6f; QUAD $0x96f4254825d362e8; QUAD $0xd162f1fe484dd162; QUAD $0x487e7162f0fe484d; WORD $0x626f; BYTE $0x32
+        TESTQ $(1<<1), R14
+        JE    skipNext1
+        MOVQ  1*24(AX), R9
+        LONG  $0x487cc162; WORD $0x0c10; BYTE $0x09
+
+skipNext1:
+        QUAD  $0x7162c4fe48555162; QUAD $0x482df162ca6f487e; QUAD $0x724825f16206c272; QUAD $0xc272481df1620bc2; QUAD $0xcacc254865736219; QUAD $0x5362c2fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62c8fe4875d162c2; QUAD $0xf16202c6724855f1; QUAD $0x1df1620dc6724825; QUAD $0x487e716216c67248; QUAD $0xc82548457362ce6f; QUAD $0x96ec254825d362e8; QUAD $0xd162e9fe4855d162; QUAD $0x487e7162e8fe4855; WORD $0x626f; BYTE $0x33
+        TESTQ $(1<<2), R14
+        JE    skipNext2
+        MOVQ  2*24(AX), R9
+        LONG  $0x487cc162; WORD $0x1410; BYTE $0x09
+
+skipNext2:
+        QUAD  $0x7162c4fe485d5162; QUAD $0x482df162c96f487e; QUAD $0x724825f16206c172; QUAD $0xc172481df1620bc1; QUAD $0xcacb25486d736219; QUAD $0x5362c3fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62c0fe487dd162c2; QUAD $0xf16202c572485df1; QUAD $0x1df1620dc5724825; QUAD $0x487e716216c57248; QUAD $0xcf25484d7362cd6f; QUAD $0x96e4254825d362e8; QUAD $0xd162e1fe485dd162; QUAD $0x487e7162e0fe485d; WORD $0x626f; BYTE $0x34
+        TESTQ $(1<<3), R14
+        JE    skipNext3
+        MOVQ  3*24(AX), R9
+        LONG  $0x487cc162; WORD $0x1c10; BYTE $0x09
+
+skipNext3:
+        QUAD  $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; WORD $0x626f; BYTE $0x35
+        TESTQ $(1<<4), R14
+        JE    skipNext4
+        MOVQ  4*24(AX), R9
+        LONG  $0x487cc162; WORD $0x2410; BYTE $0x09
+
+skipNext4:
+        QUAD  $0x7162c4fe486d5162; QUAD $0x482df162cf6f487e; QUAD $0x724825f16206c772; QUAD $0xc772481df1620bc7; QUAD $0xcac925487d736219; QUAD $0x5362c5fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f0fe484dd162c2; QUAD $0xf16202c372486df1; QUAD $0x1df1620dc3724825; QUAD $0x487e716216c37248; QUAD $0xcd25485d7362cb6f; QUAD $0x96d4254825d362e8; QUAD $0xd162d1fe486dd162; QUAD $0x487e7162d0fe486d; WORD $0x626f; BYTE $0x36
+        TESTQ $(1<<5), R14
+        JE    skipNext5
+        MOVQ  5*24(AX), R9
+        LONG  $0x487cc162; WORD $0x2c10; BYTE $0x09
+
+skipNext5:
+        QUAD  $0x7162c4fe48755162; QUAD $0x482df162ce6f487e; QUAD $0x724825f16206c672; QUAD $0xc672481df1620bc6; QUAD $0xcac8254845736219; QUAD $0x5362c6fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62e8fe4855d162c2; QUAD $0xf16202c2724875f1; QUAD $0x1df1620dc2724825; QUAD $0x487e716216c27248; QUAD $0xcc2548657362ca6f; QUAD $0x96cc254825d362e8; QUAD $0xd162c9fe4875d162; QUAD $0x487e7162c8fe4875; WORD $0x626f; BYTE $0x37
+        TESTQ $(1<<6), R14
+        JE    skipNext6
+        MOVQ  6*24(AX), R9
+        LONG  $0x487cc162; WORD $0x3410; BYTE $0x09
+
+skipNext6:
+        QUAD  $0x7162c4fe487d5162; QUAD $0x482df162cd6f487e; QUAD $0x724825f16206c572; QUAD $0xc572481df1620bc5; QUAD $0xcacf25484d736219; QUAD $0x5362c7fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62e0fe485dd162c2; QUAD $0xf16202c172487df1; QUAD $0x1df1620dc1724825; QUAD $0x487e716216c17248; QUAD $0xcb25486d7362c96f; QUAD $0x96c4254825d362e8; QUAD $0xd162c1fe487dd162; QUAD $0x487e7162c0fe487d; WORD $0x626f; BYTE $0x38
+        TESTQ $(1<<7), R14
+        JE    skipNext7
+        MOVQ  7*24(AX), R9
+        LONG  $0x487cc162; WORD $0x3c10; BYTE $0x09
+
+skipNext7:
+        QUAD  $0x7162c4fe48455162; QUAD $0x482df162cc6f487e; QUAD $0x724825f16206c472; QUAD $0xc472481df1620bc4; QUAD $0xcace254855736219; QUAD $0x5362c0fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d8fe4865d162c2; QUAD $0xf16202c0724845f1; QUAD $0x1df1620dc0724825; QUAD $0x487e716216c07248; QUAD $0xca2548757362c86f; QUAD $0x96fc254825d362e8; QUAD $0xd162f9fe4845d162; QUAD $0x487e7162f8fe4845; WORD $0x626f; BYTE $0x39
+        TESTQ $(1<<8), R14
+        JE    skipNext8
+        MOVQ  8*24(AX), R9
+        LONG  $0x487c4162; WORD $0x0410; BYTE $0x09
+
+skipNext8:
+        QUAD  $0x7162c4fe484d5162; QUAD $0x482df162cb6f487e; QUAD $0x724825f16206c372; QUAD $0xc372481df1620bc3; QUAD $0xcacd25485d736219; QUAD $0x5362c1fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d0fe486dd162c2; QUAD $0xf16202c772484df1; QUAD $0x1df1620dc7724825; QUAD $0x487e716216c77248; QUAD $0xc925487d7362cf6f; QUAD $0x96f4254825d362e8; QUAD $0xd162f1fe484dd162; QUAD $0x487e7162f0fe484d; WORD $0x626f; BYTE $0x3a
+        TESTQ $(1<<9), R14
+        JE    skipNext9
+        MOVQ  9*24(AX), R9
+        LONG  $0x487c4162; WORD $0x0c10; BYTE $0x09
+
+skipNext9:
+        QUAD  $0x7162c4fe48555162; QUAD $0x482df162ca6f487e; QUAD $0x724825f16206c272; QUAD $0xc272481df1620bc2; QUAD $0xcacc254865736219; QUAD $0x5362c2fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62c8fe4875d162c2; QUAD $0xf16202c6724855f1; QUAD $0x1df1620dc6724825; QUAD $0x487e716216c67248; QUAD $0xc82548457362ce6f; QUAD $0x96ec254825d362e8; QUAD $0xd162e9fe4855d162; QUAD $0x487e7162e8fe4855; WORD $0x626f; BYTE $0x3b
+        TESTQ $(1<<10), R14
+        JE    skipNext10
+        MOVQ  10*24(AX), R9
+        LONG  $0x487c4162; WORD $0x1410; BYTE $0x09
+
+skipNext10:
+        QUAD  $0x7162c4fe485d5162; QUAD $0x482df162c96f487e; QUAD $0x724825f16206c172; QUAD $0xc172481df1620bc1; QUAD $0xcacb25486d736219; QUAD $0x5362c3fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62c0fe487dd162c2; QUAD $0xf16202c572485df1; QUAD $0x1df1620dc5724825; QUAD $0x487e716216c57248; QUAD $0xcf25484d7362cd6f; QUAD $0x96e4254825d362e8; QUAD $0xd162e1fe485dd162; QUAD $0x487e7162e0fe485d; WORD $0x626f; BYTE $0x3c
+        TESTQ $(1<<11), R14
+        JE    skipNext11
+        MOVQ  11*24(AX), R9
+        LONG  $0x487c4162; WORD $0x1c10; BYTE $0x09
+
+skipNext11:
+        QUAD  $0x7162c4fe48655162; QUAD $0x482df162c86f487e; QUAD $0x724825f16206c072; QUAD $0xc072481df1620bc0; QUAD $0xcaca254875736219; QUAD $0x5362c4fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f8fe4845d162c2; QUAD $0xf16202c4724865f1; QUAD $0x1df1620dc4724825; QUAD $0x487e716216c47248; QUAD $0xce2548557362cc6f; QUAD $0x96dc254825d362e8; QUAD $0xd162d9fe4865d162; QUAD $0x487e7162d8fe4865; WORD $0x626f; BYTE $0x3d
+        TESTQ $(1<<12), R14
+        JE    skipNext12
+        MOVQ  12*24(AX), R9
+        LONG  $0x487c4162; WORD $0x2410; BYTE $0x09
+
+skipNext12:
+        QUAD  $0x7162c4fe486d5162; QUAD $0x482df162cf6f487e; QUAD $0x724825f16206c772; QUAD $0xc772481df1620bc7; QUAD $0xcac925487d736219; QUAD $0x5362c5fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62f0fe484dd162c2; QUAD $0xf16202c372486df1; QUAD $0x1df1620dc3724825; QUAD $0x487e716216c37248; QUAD $0xcd25485d7362cb6f; QUAD $0x96d4254825d362e8; QUAD $0xd162d1fe486dd162; QUAD $0x487e7162d0fe486d; WORD $0x626f; BYTE $0x3e
+        TESTQ $(1<<13), R14
+        JE    skipNext13
+        MOVQ  13*24(AX), R9
+        LONG  $0x487c4162; WORD $0x2c10; BYTE $0x09
+
+skipNext13:
+        QUAD  $0x7162c4fe48755162; QUAD $0x482df162ce6f487e; QUAD $0x724825f16206c672; QUAD $0xc672481df1620bc6; QUAD $0xcac8254845736219; QUAD $0x5362c6fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62e8fe4855d162c2; QUAD $0xf16202c2724875f1; QUAD $0x1df1620dc2724825; QUAD $0x487e716216c27248; QUAD $0xcc2548657362ca6f; QUAD $0x96cc254825d362e8; QUAD $0xd162c9fe4875d162; QUAD $0x487e7162c8fe4875; WORD $0x626f; BYTE $0x3f
+        TESTQ $(1<<14), R14
+        JE    skipNext14
+        MOVQ  14*24(AX), R9
+        LONG  $0x487c4162; WORD $0x3410; BYTE $0x09
+
+skipNext14:
+        QUAD  $0x7162c4fe487d5162; QUAD $0x482df162cd6f487e; QUAD $0x724825f16206c572; QUAD $0xc572481df1620bc5; QUAD $0xcacf25484d736219; QUAD $0x5362c7fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62e0fe485dd162c2; QUAD $0xf16202c172487df1; QUAD $0x1df1620dc1724825; QUAD $0x487e716216c17248; QUAD $0xcb25486d7362c96f; QUAD $0x96c4254825d362e8; QUAD $0xd162c1fe487dd162; QUAD $0x487e7162c0fe487d; WORD $0x626f; BYTE $0x40
+        TESTQ $(1<<15), R14
+        JE    skipNext15
+        MOVQ  15*24(AX), R9
+        LONG  $0x487c4162; WORD $0x3c10; BYTE $0x09
+
+skipNext15:
+        QUAD $0xd162d86f487e7162; QUAD $0x7dd16224046f487e; QUAD $0x6f487e7162c3fe49; QUAD $0x244c6f487ed162d9; QUAD $0x62cbfe4975d16201; QUAD $0x7ed162da6f487e71; QUAD $0x6dd1620224546f48; QUAD $0x6f487e7162d3fe49; QUAD $0x245c6f487ed162db; QUAD $0x62dbfe4965d16203; QUAD $0x7ed162dc6f487e71; QUAD $0x5dd1620424646f48; QUAD $0x6f487e7162e3fe49; QUAD $0x246c6f487ed162dd; QUAD $0x62ebfe4955d16205; QUAD $0x7ed162de6f487e71; QUAD $0x4dd1620624746f48; QUAD $0x6f487e7162f3fe49; QUAD $0x247c6f487ed162df; QUAD $0xc4fbfe4945d16207; LONG $0xce92fbc1
+        JMP  lloop
+
+lastLoop:
+        QUAD         $0x7162c4fe48455162; QUAD $0x482df162cc6f487e; QUAD $0x724825f16206c472; QUAD $0xc472481df1620bc4; QUAD $0xcace254855736219; QUAD $0x5362c0fe483d3162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d8fe4865d162c2; QUAD $0xf16202c0724845f1; QUAD $0x1df1620dc0724825; QUAD $0x487e716216c07248; QUAD $0xca2548757362c86f; QUAD $0x96fc254825d362e8; QUAD $0xd162f9fe4845d162; QUAD $0x487e7162f8fe4845; QUAD $0xfe484d516231626f; QUAD $0x62cb6f487e7162c4; QUAD $0xf16206c372482df1; QUAD $0x1df1620bc3724825; QUAD $0x485d736219c37248; QUAD $0xfe483d3162cacd25; QUAD $0x96d42548255362c1; QUAD $0x5162c1fe483d5162; QUAD $0x486dd162c2fe483d; QUAD $0xc772484df162d0fe; QUAD $0x0dc7724825f16202; QUAD $0x6216c772481df162; QUAD $0x7d7362cf6f487e71; QUAD $0x4825d362e8c92548; QUAD $0xfe484dd16296f425; QUAD $0x62f0fe484dd162f1; QUAD $0x516232626f487e71; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x3162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x62c4fe485d516233; QUAD $0x2df162c96f487e71; QUAD $0x4825f16206c17248; QUAD $0x72481df1620bc172; QUAD $0xcb25486d736219c1; QUAD $0x62c3fe483d3162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xc0fe487dd162c2fe; QUAD $0x6202c572485df162; QUAD $0xf1620dc5724825f1; QUAD $0x7e716216c572481d; QUAD $0x25484d7362cd6f48; QUAD $0xe4254825d362e8cf; QUAD $0x62e1fe485dd16296; QUAD $0x7e7162e0fe485dd1; QUAD $0x4865516234626f48; QUAD $0xc86f487e7162c4fe; QUAD $0x6206c072482df162; QUAD $0xf1620bc0724825f1; QUAD $0x75736219c072481d; QUAD $0x483d3162caca2548; QUAD $0xd42548255362c4fe; QUAD $0x62c1fe483d516296; QUAD $0x45d162c2fe483d51; QUAD $0x724865f162f8fe48; QUAD $0xc4724825f16202c4; QUAD $0x16c472481df1620d; QUAD $0x7362cc6f487e7162; QUAD $0x25d362e8ce254855; QUAD $0x4865d16296dc2548; QUAD $0xd8fe4865d162d9fe; QUAD $0x6235626f487e7162; QUAD $0x7e7162c4fe486d51; QUAD $0x72482df162cf6f48; QUAD $0xc7724825f16206c7; QUAD $0x19c772481df1620b; QUAD $0x62cac925487d7362; QUAD $0x255362c5fe483d31; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162f0fe484dd162; QUAD $0x25f16202c372486d; QUAD $0x481df1620dc37248; QUAD $0x6f487e716216c372; QUAD $0xe8cd25485d7362cb; QUAD $0x6296d4254825d362; QUAD $0x6dd162d1fe486dd1; QUAD $0x6f487e7162d0fe48; QUAD $0xc4fe487551623662; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d3162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x7d516237626f487e; QUAD $0x6f487e7162c4fe48; QUAD $0x06c572482df162cd; QUAD $0x620bc5724825f162; QUAD $0x736219c572481df1; QUAD $0x3d3162cacf25484d; QUAD $0x2548255362c7fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x487df162e0fe485d; QUAD $0x724825f16202c172; QUAD $0xc172481df1620dc1; QUAD $0x62c96f487e716216; QUAD $0xd362e8cb25486d73; QUAD $0x7dd16296c4254825; QUAD $0xfe487dd162c1fe48; QUAD $0x38626f487e7162c0; QUAD $0x7162c4fe48455162; QUAD $0x482df162cc6f487e; QUAD $0x724825f16206c472; QUAD $0xc472481df1620bc4; QUAD $0xcace254855736219; QUAD $0x5362c0fe483d1162; QUAD $0x3d516296d4254825; QUAD $0xfe483d5162c1fe48; QUAD $0x62d8fe4865d162c2; QUAD $0xf16202c0724845f1; QUAD $0x1df1620dc0724825; QUAD $0x487e716216c07248; QUAD $0xca2548757362c86f; QUAD $0x96fc254825d362e8; QUAD $0xd162f9fe4845d162; QUAD $0x487e7162f8fe4845; QUAD $0xfe484d516239626f; QUAD $0x62cb6f487e7162c4; QUAD $0xf16206c372482df1; QUAD $0x1df1620bc3724825; QUAD $0x485d736219c37248; QUAD $0xfe483d1162cacd25; QUAD $0x96d42548255362c1; QUAD $0x5162c1fe483d5162; QUAD $0x486dd162c2fe483d; QUAD $0xc772484df162d0fe; QUAD $0x0dc7724825f16202; QUAD $0x6216c772481df162; QUAD $0x7d7362cf6f487e71; QUAD $0x4825d362e8c92548; QUAD $0xfe484dd16296f425; QUAD $0x62f0fe484dd162f1; QUAD $0x51623a626f487e71; QUAD $0x487e7162c4fe4855; QUAD $0xc272482df162ca6f; QUAD $0x0bc2724825f16206; QUAD $0x6219c272481df162; QUAD $0x1162cacc25486573; QUAD $0x48255362c2fe483d; QUAD $0xfe483d516296d425; QUAD $0x62c2fe483d5162c1; QUAD $0x55f162c8fe4875d1; QUAD $0x4825f16202c67248; QUAD $0x72481df1620dc672; QUAD $0xce6f487e716216c6; QUAD $0x62e8c82548457362; QUAD $0xd16296ec254825d3; QUAD $0x4855d162e9fe4855; QUAD $0x626f487e7162e8fe; QUAD $0x62c4fe485d51623b; QUAD $0x2df162c96f487e71; QUAD $0x4825f16206c17248; QUAD $0x72481df1620bc172; QUAD $0xcb25486d736219c1; QUAD $0x62c3fe483d1162ca; QUAD $0x516296d425482553; QUAD $0x483d5162c1fe483d; QUAD $0xc0fe487dd162c2fe; QUAD $0x6202c572485df162; QUAD $0xf1620dc5724825f1; QUAD $0x7e716216c572481d; QUAD $0x25484d7362cd6f48; QUAD $0xe4254825d362e8cf; QUAD $0x62e1fe485dd16296; QUAD $0x7e7162e0fe485dd1; QUAD $0x486551623c626f48; QUAD $0xc86f487e7162c4fe; QUAD $0x6206c072482df162; QUAD $0xf1620bc0724825f1; QUAD $0x75736219c072481d; QUAD $0x483d1162caca2548; QUAD $0xd42548255362c4fe; QUAD $0x62c1fe483d516296; QUAD $0x45d162c2fe483d51; QUAD $0x724865f162f8fe48; QUAD $0xc4724825f16202c4; QUAD $0x16c472481df1620d; QUAD $0x7362cc6f487e7162; QUAD $0x25d362e8ce254855; QUAD $0x4865d16296dc2548; QUAD $0xd8fe4865d162d9fe; QUAD $0x623d626f487e7162; QUAD $0x7e7162c4fe486d51; QUAD $0x72482df162cf6f48; QUAD $0xc7724825f16206c7; QUAD $0x19c772481df1620b; QUAD $0x62cac925487d7362; QUAD $0x255362c5fe483d11; QUAD $0x483d516296d42548; QUAD $0xc2fe483d5162c1fe; QUAD $0xf162f0fe484dd162; QUAD $0x25f16202c372486d; QUAD $0x481df1620dc37248; QUAD $0x6f487e716216c372; QUAD $0xe8cd25485d7362cb; QUAD $0x6296d4254825d362; QUAD $0x6dd162d1fe486dd1; QUAD $0x6f487e7162d0fe48; QUAD $0xc4fe487551623e62; QUAD $0xf162ce6f487e7162; QUAD $0x25f16206c672482d; QUAD $0x481df1620bc67248; QUAD $0x254845736219c672; QUAD $0xc6fe483d1162cac8; QUAD $0x6296d42548255362; QUAD $0x3d5162c1fe483d51; QUAD $0xfe4855d162c2fe48; QUAD $0x02c2724875f162e8; QUAD $0x620dc2724825f162; QUAD $0x716216c272481df1; QUAD $0x48657362ca6f487e; QUAD $0x254825d362e8cc25; QUAD $0xc9fe4875d16296cc; QUAD $0x7162c8fe4875d162; QUAD $0x7d51623f626f487e; QUAD $0x6f487e7162c4fe48; QUAD $0x06c572482df162cd; QUAD $0x620bc5724825f162; QUAD $0x736219c572481df1; QUAD $0x3d1162cacf25484d; QUAD $0x2548255362c7fe48; QUAD $0xc1fe483d516296d4; QUAD $0xd162c2fe483d5162; QUAD $0x487df162e0fe485d; QUAD $0x724825f16202c172; QUAD $0xc172481df1620dc1; QUAD $0x62c96f487e716216; QUAD $0xd362e8cb25486d73; QUAD $0x7dd16296c4254825; QUAD $0xfe487dd162c1fe48; QUAD $0x40626f487e7162c0; QUAD $0xd162d86f487e7162; QUAD $0x7dd16224046f487e; QUAD $0x6f487e7162c3fe49; QUAD $0x244c6f487ed162d9; QUAD $0x62cbfe4975d16201; QUAD $0x7ed162da6f487e71; QUAD $0x6dd1620224546f48; QUAD $0x6f487e7162d3fe49; QUAD $0x245c6f487ed162db; QUAD $0x62dbfe4965d16203; QUAD $0x7ed162dc6f487e71; QUAD $0x5dd1620424646f48; QUAD $0x6f487e7162e3fe49; QUAD $0x246c6f487ed162dd; QUAD $0x62ebfe4955d16205; QUAD $0x7ed162de6f487e71; QUAD $0x4dd1620624746f48; QUAD $0x6f487e7162f3fe49; QUAD $0x247c6f487ed162df; QUAD $0x62fbfe4945d16207; QUAD $0x7ef162077f487ef1; QUAD $0x487ef162014f7f48; QUAD $0x7f487ef16202577f; QUAD $0x677f487ef162035f; QUAD $0x056f7f487ef16204; QUAD $0x6206777f487ef162; LONG $0x7f487ef1; WORD $0x077f
+        VZEROUPPER
+        RET
+
+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
diff --git a/vendor/github.com/minio/sha256-simd/sha256block_amd64.go b/vendor/github.com/minio/sha256-simd/sha256block_amd64.go
new file mode 100644
index 0000000..e536f54
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_amd64.go
@@ -0,0 +1,31 @@
+//go:build !noasm && !appengine && gc
+// +build !noasm,!appengine,gc
+
+/*
+ * 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 blockArmSha2Go(dig *digest, p []byte) {
+        panic("blockArmSha2Go called unexpectedly")
+}
+
+//go:noescape
+func blockIntelSha(h *[8]uint32, message []uint8)
+
+func blockIntelShaGo(dig *digest, p []byte) {
+        blockIntelSha(&dig.h, p)
+}
diff --git a/vendor/github.com/minio/sha256-simd/sha256block_amd64.s b/vendor/github.com/minio/sha256-simd/sha256block_amd64.s
new file mode 100644
index 0000000..c98a1d8
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_amd64.s
@@ -0,0 +1,266 @@
+//+build !noasm,!appengine,gc
+
+// 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 ·blockIntelSha(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
diff --git a/vendor/github.com/minio/sha256-simd/sha256block_arm64.go b/vendor/github.com/minio/sha256-simd/sha256block_arm64.go
new file mode 100644
index 0000000..d4369e2
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_arm64.go
@@ -0,0 +1,37 @@
+//go:build !noasm && !appengine && gc
+// +build !noasm,!appengine,gc
+
+/*
+ * 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 blockIntelShaGo(dig *digest, p []byte) {
+        panic("blockIntelShaGo called unexpectedly")
+}
+
+//go:noescape
+func blockArmSha2(h []uint32, message []uint8)
+
+func blockArmSha2Go(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]}
+
+        blockArmSha2(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]
+}
diff --git a/vendor/github.com/minio/sha256-simd/sha256block_arm64.s b/vendor/github.com/minio/sha256-simd/sha256block_arm64.s
new file mode 100644
index 0000000..7ab88b1
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_arm64.s
@@ -0,0 +1,192 @@
+//+build !noasm,!appengine,gc
+
+// 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 ·blockArmSha2(SB), 7, $0
+        MOVD h+0(FP), R0
+        MOVD message+24(FP), R1
+        MOVD message_len+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
+
diff --git a/vendor/github.com/minio/sha256-simd/sha256block_other.go b/vendor/github.com/minio/sha256-simd/sha256block_other.go
new file mode 100644
index 0000000..94d7eb0
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/sha256block_other.go
@@ -0,0 +1,29 @@
+//go:build appengine || noasm || (!amd64 && !arm64) || !gc
+// +build appengine noasm !amd64,!arm64 !gc
+
+/*
+ * Minio Cloud Storage, (C) 2019 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 blockIntelShaGo(dig *digest, p []byte) {
+        panic("blockIntelShaGo called unexpectedly")
+
+}
+
+func blockArmSha2Go(dig *digest, p []byte) {
+        panic("blockArmSha2Go called unexpectedly")
+}
diff --git a/vendor/github.com/minio/sha256-simd/test-architectures.sh b/vendor/github.com/minio/sha256-simd/test-architectures.sh
new file mode 100644
index 0000000..50150ea
--- /dev/null
+++ b/vendor/github.com/minio/sha256-simd/test-architectures.sh
@@ -0,0 +1,15 @@
+#!/bin/sh
+
+set -e
+
+go tool dist list | while IFS=/ read os arch; do
+    echo "Checking $os/$arch..."
+    echo " normal"
+    GOARCH=$arch GOOS=$os go build -o /dev/null ./...
+    echo " noasm"
+    GOARCH=$arch GOOS=$os go build -tags noasm -o /dev/null ./...
+    echo " appengine"
+    GOARCH=$arch GOOS=$os go build -tags appengine -o /dev/null ./...
+    echo " noasm,appengine"
+    GOARCH=$arch GOOS=$os go build -tags 'appengine noasm' -o /dev/null ./...
+done
diff --git a/vendor/github.com/modern-go/concurrent/.gitignore b/vendor/github.com/modern-go/concurrent/.gitignore
new file mode 100644
index 0000000..3f2bc47
--- /dev/null
+++ b/vendor/github.com/modern-go/concurrent/.gitignore
@@ -0,0 +1 @@
+/coverage.txt
diff --git a/vendor/github.com/modern-go/concurrent/.travis.yml b/vendor/github.com/modern-go/concurrent/.travis.yml
new file mode 100644
index 0000000..449e67c
--- /dev/null
+++ b/vendor/github.com/modern-go/concurrent/.travis.yml
@@ -0,0 +1,14 @@
+language: go
+
+go:
+  - 1.8.x
+  - 1.x
+
+before_install:
+  - go get -t -v ./...
+
+script:
+  - ./test.sh
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)
diff --git a/vendor/github.com/modern-go/concurrent/LICENSE b/vendor/github.com/modern-go/concurrent/LICENSE
new file mode 100644
index 0000000..261eeb9
--- /dev/null
+++ b/vendor/github.com/modern-go/concurrent/LICENSE
@@ -0,0 +1,201 @@
+                                 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.
diff --git a/vendor/github.com/modern-go/concurrent/README.md b/vendor/github.com/modern-go/concurrent/README.md
new file mode 100644
index 0000000..acab320
--- /dev/null
+++ b/vendor/github.com/modern-go/concurrent/README.md
@@ -0,0 +1,49 @@
+# concurrent
+
+[![Sourcegraph](https://sourcegraph.com/github.com/modern-go/concurrent/-/badge.svg)](https://sourcegraph.com/github.com/modern-go/concurrent?badge)
+[![GoDoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](http://godoc.org/github.com/modern-go/concurrent)
+[![Build Status](https://travis-ci.org/modern-go/concurrent.svg?branch=master)](https://travis-ci.org/modern-go/concurrent)
+[![codecov](https://codecov.io/gh/modern-go/concurrent/branch/master/graph/badge.svg)](https://codecov.io/gh/modern-go/concurrent)
+[![rcard](https://goreportcard.com/badge/github.com/modern-go/concurrent)](https://goreportcard.com/report/github.com/modern-go/concurrent)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://raw.githubusercontent.com/modern-go/concurrent/master/LICENSE)
+
+* concurrent.Map: backport sync.Map for go below 1.9
+* concurrent.Executor: goroutine with explicit ownership and cancellable
+
+# concurrent.Map
+
+because sync.Map is only available in go 1.9, we can use concurrent.Map to make code portable
+
+```go
+m := concurrent.NewMap()
+m.Store("hello", "world")
+elem, found := m.Load("hello")
+// elem will be "world"
+// found will be true
+```
+
+# concurrent.Executor
+
+```go
+executor := concurrent.NewUnboundedExecutor()
+executor.Go(func(ctx context.Context) {
+    everyMillisecond := time.NewTicker(time.Millisecond)
+    for {
+        select {
+        case <-ctx.Done():
+            fmt.Println("goroutine exited")
+            return
+        case <-everyMillisecond.C:
+            // do something
+        }
+    }
+})
+time.Sleep(time.Second)
+executor.StopAndWaitForever()
+fmt.Println("executor stopped")
+```
+
+attach goroutine to executor instance, so that we can
+
+* cancel it by stop the executor with Stop/StopAndWait/StopAndWaitForever
+* handle panic by callback: the default behavior will no longer crash your application
\ No newline at end of file
diff --git a/vendor/github.com/modern-go/concurrent/executor.go b/vendor/github.com/modern-go/concurrent/executor.go
new file mode 100644
index 0000000..623dba1
--- /dev/null
+++ b/vendor/github.com/modern-go/concurrent/executor.go
@@ -0,0 +1,14 @@
+package concurrent
+
+import "context"
+
+// Executor replace go keyword to start a new goroutine
+// the goroutine should cancel itself if the context passed in has been cancelled
+// the goroutine started by the executor, is owned by the executor
+// we can cancel all executors owned by the executor just by stop the executor itself
+// however Executor interface does not Stop method, the one starting and owning executor
+// should use the concrete type of executor, instead of this interface.
+type Executor interface {
+        // Go starts a new goroutine controlled by the context
+        Go(handler func(ctx context.Context))
+}
diff --git a/vendor/github.com/modern-go/concurrent/go_above_19.go b/vendor/github.com/modern-go/concurrent/go_above_19.go
new file mode 100644
index 0000000..aeabf8c
--- /dev/null
+++ b/vendor/github.com/modern-go/concurrent/go_above_19.go
@@ -0,0 +1,15 @@
+//+build go1.9
+
+package concurrent
+
+import "sync"
+
+// Map is a wrapper for sync.Map introduced in go1.9
+type Map struct {
+        sync.Map
+}
+
+// NewMap creates a thread safe Map
+func NewMap() *Map {
+        return &Map{}
+}
diff --git a/vendor/github.com/modern-go/concurrent/go_below_19.go b/vendor/github.com/modern-go/concurrent/go_below_19.go
new file mode 100644
index 0000000..b9c8df7
--- /dev/null
+++ b/vendor/github.com/modern-go/concurrent/go_below_19.go
@@ -0,0 +1,33 @@
+//+build !go1.9
+
+package concurrent
+
+import "sync"
+
+// Map implements a thread safe map for go version below 1.9 using mutex
+type Map struct {
+        lock sync.RWMutex
+        data map[interface{}]interface{}
+}
+
+// NewMap creates a thread safe map
+func NewMap() *Map {
+        return &Map{
+                data: make(map[interface{}]interface{}, 32),
+        }
+}
+
+// Load is same as sync.Map Load
+func (m *Map) Load(key interface{}) (elem interface{}, found bool) {
+        m.lock.RLock()
+        elem, found = m.data[key]
+        m.lock.RUnlock()
+        return
+}
+
+// Load is same as sync.Map Store
+func (m *Map) Store(key interface{}, elem interface{}) {
+        m.lock.Lock()
+        m.data[key] = elem
+        m.lock.Unlock()
+}
diff --git a/vendor/github.com/modern-go/concurrent/log.go b/vendor/github.com/modern-go/concurrent/log.go
new file mode 100644
index 0000000..9756fcc
--- /dev/null
+++ b/vendor/github.com/modern-go/concurrent/log.go
@@ -0,0 +1,13 @@
+package concurrent
+
+import (
+        "os"
+        "log"
+        "io/ioutil"
+)
+
+// ErrorLogger is used to print out error, can be set to writer other than stderr
+var ErrorLogger = log.New(os.Stderr, "", 0)
+
+// InfoLogger is used to print informational message, default to off
+var InfoLogger = log.New(ioutil.Discard, "", 0)
\ No newline at end of file
diff --git a/vendor/github.com/modern-go/concurrent/test.sh b/vendor/github.com/modern-go/concurrent/test.sh
new file mode 100644
index 0000000..d1e6b2e
--- /dev/null
+++ b/vendor/github.com/modern-go/concurrent/test.sh
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+set -e
+echo "" > coverage.txt
+
+for d in $(go list ./... | grep -v vendor); do
+    go test -coverprofile=profile.out -coverpkg=github.com/modern-go/concurrent $d
+    if [ -f profile.out ]; then
+        cat profile.out >> coverage.txt
+        rm profile.out
+    fi
+done
diff --git a/vendor/github.com/modern-go/concurrent/unbounded_executor.go b/vendor/github.com/modern-go/concurrent/unbounded_executor.go
new file mode 100644
index 0000000..05a77dc
--- /dev/null
+++ b/vendor/github.com/modern-go/concurrent/unbounded_executor.go
@@ -0,0 +1,119 @@
+package concurrent
+
+import (
+        "context"
+        "fmt"
+        "runtime"
+        "runtime/debug"
+        "sync"
+        "time"
+        "reflect"
+)
+
+// HandlePanic logs goroutine panic by default
+var HandlePanic = func(recovered interface{}, funcName string) {
+        ErrorLogger.Println(fmt.Sprintf("%s panic: %v", funcName, recovered))
+        ErrorLogger.Println(string(debug.Stack()))
+}
+
+// UnboundedExecutor is a executor without limits on counts of alive goroutines
+// it tracks the goroutine started by it, and can cancel them when shutdown
+type UnboundedExecutor struct {
+        ctx                   context.Context
+        cancel                context.CancelFunc
+        activeGoroutinesMutex *sync.Mutex
+        activeGoroutines      map[string]int
+        HandlePanic           func(recovered interface{}, funcName string)
+}
+
+// GlobalUnboundedExecutor has the life cycle of the program itself
+// any goroutine want to be shutdown before main exit can be started from this executor
+// GlobalUnboundedExecutor expects the main function to call stop
+// it does not magically knows the main function exits
+var GlobalUnboundedExecutor = NewUnboundedExecutor()
+
+// NewUnboundedExecutor creates a new UnboundedExecutor,
+// UnboundedExecutor can not be created by &UnboundedExecutor{}
+// HandlePanic can be set with a callback to override global HandlePanic
+func NewUnboundedExecutor() *UnboundedExecutor {
+        ctx, cancel := context.WithCancel(context.TODO())
+        return &UnboundedExecutor{
+                ctx:                   ctx,
+                cancel:                cancel,
+                activeGoroutinesMutex: &sync.Mutex{},
+                activeGoroutines:      map[string]int{},
+        }
+}
+
+// Go starts a new goroutine and tracks its lifecycle.
+// Panic will be recovered and logged automatically, except for StopSignal
+func (executor *UnboundedExecutor) Go(handler func(ctx context.Context)) {
+        pc := reflect.ValueOf(handler).Pointer()
+        f := runtime.FuncForPC(pc)
+        funcName := f.Name()
+        file, line := f.FileLine(pc)
+        executor.activeGoroutinesMutex.Lock()
+        defer executor.activeGoroutinesMutex.Unlock()
+        startFrom := fmt.Sprintf("%s:%d", file, line)
+        executor.activeGoroutines[startFrom] += 1
+        go func() {
+                defer func() {
+                        recovered := recover()
+                        // if you want to quit a goroutine without trigger HandlePanic
+                        // use runtime.Goexit() to quit
+                        if recovered != nil {
+                                if executor.HandlePanic == nil {
+                                        HandlePanic(recovered, funcName)
+                                } else {
+                                        executor.HandlePanic(recovered, funcName)
+                                }
+                        }
+                        executor.activeGoroutinesMutex.Lock()
+                        executor.activeGoroutines[startFrom] -= 1
+                        executor.activeGoroutinesMutex.Unlock()
+                }()
+                handler(executor.ctx)
+        }()
+}
+
+// Stop cancel all goroutines started by this executor without wait
+func (executor *UnboundedExecutor) Stop() {
+        executor.cancel()
+}
+
+// StopAndWaitForever cancel all goroutines started by this executor and
+// wait until all goroutines exited
+func (executor *UnboundedExecutor) StopAndWaitForever() {
+        executor.StopAndWait(context.Background())
+}
+
+// StopAndWait cancel all goroutines started by this executor and wait.
+// Wait can be cancelled by the context passed in.
+func (executor *UnboundedExecutor) StopAndWait(ctx context.Context) {
+        executor.cancel()
+        for {
+                oneHundredMilliseconds := time.NewTimer(time.Millisecond * 100)
+                select {
+                case <-oneHundredMilliseconds.C:
+                        if executor.checkNoActiveGoroutines() {
+                                return
+                        }
+                case <-ctx.Done():
+                        return
+                }
+        }
+}
+
+func (executor *UnboundedExecutor) checkNoActiveGoroutines() bool {
+        executor.activeGoroutinesMutex.Lock()
+        defer executor.activeGoroutinesMutex.Unlock()
+        for startFrom, count := range executor.activeGoroutines {
+                if count > 0 {
+                        InfoLogger.Println("UnboundedExecutor is still waiting goroutines to quit",
+                                "startFrom", startFrom,
+                                "count", count)
+                        return false
+                }
+        }
+        return true
+}
diff --git a/vendor/github.com/modern-go/reflect2/.gitignore b/vendor/github.com/modern-go/reflect2/.gitignore
new file mode 100644
index 0000000..7b26c94
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/.gitignore
@@ -0,0 +1,2 @@
+/vendor
+/coverage.txt
diff --git a/vendor/github.com/modern-go/reflect2/.travis.yml b/vendor/github.com/modern-go/reflect2/.travis.yml
new file mode 100644
index 0000000..b097728
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/.travis.yml
@@ -0,0 +1,15 @@
+language: go
+
+go:
+  - 1.9.x
+  - 1.x
+
+before_install:
+  - go get -t -v ./...
+  - go get -t -v github.com/modern-go/reflect2-tests/...
+
+script:
+  - ./test.sh
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)
diff --git a/vendor/github.com/modern-go/reflect2/Gopkg.lock b/vendor/github.com/modern-go/reflect2/Gopkg.lock
new file mode 100644
index 0000000..10ef811
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/Gopkg.lock
@@ -0,0 +1,9 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  input-imports = []
+  solver-name = "gps-cdcl"
+  solver-version = 1
diff --git a/vendor/github.com/modern-go/reflect2/Gopkg.toml b/vendor/github.com/modern-go/reflect2/Gopkg.toml
new file mode 100644
index 0000000..a9bc506
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/Gopkg.toml
@@ -0,0 +1,31 @@
+# Gopkg.toml example
+#
+# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+ignored = []
+
+[prune]
+  go-tests = true
+  unused-packages = true
diff --git a/vendor/github.com/modern-go/reflect2/LICENSE b/vendor/github.com/modern-go/reflect2/LICENSE
new file mode 100644
index 0000000..261eeb9
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/LICENSE
@@ -0,0 +1,201 @@
+                                 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.
diff --git a/vendor/github.com/modern-go/reflect2/README.md b/vendor/github.com/modern-go/reflect2/README.md
new file mode 100644
index 0000000..6f968aa
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/README.md
@@ -0,0 +1,71 @@
+# reflect2
+
+[![Sourcegraph](https://sourcegraph.com/github.com/modern-go/reflect2/-/badge.svg)](https://sourcegraph.com/github.com/modern-go/reflect2?badge)
+[![GoDoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](http://godoc.org/github.com/modern-go/reflect2)
+[![Build Status](https://travis-ci.org/modern-go/reflect2.svg?branch=master)](https://travis-ci.org/modern-go/reflect2)
+[![codecov](https://codecov.io/gh/modern-go/reflect2/branch/master/graph/badge.svg)](https://codecov.io/gh/modern-go/reflect2)
+[![rcard](https://goreportcard.com/badge/github.com/modern-go/reflect2)](https://goreportcard.com/report/github.com/modern-go/reflect2)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://raw.githubusercontent.com/modern-go/reflect2/master/LICENSE)
+
+reflect api that avoids runtime reflect.Value cost
+
+* reflect get/set interface{}, with type checking
+* reflect get/set unsafe.Pointer, without type checking
+* `reflect2.TypeByName` works like `Class.forName` found in java
+
+[json-iterator](https://github.com/json-iterator/go) use this package to save runtime dispatching cost.
+This package is designed for low level libraries to optimize reflection performance.
+General application should still use reflect standard library.
+
+# reflect2.TypeByName
+
+```go
+// given package is github.com/your/awesome-package
+type MyStruct struct {
+        // ...
+}
+
+// will return the type
+reflect2.TypeByName("awesome-package.MyStruct")
+// however, if the type has not been used
+// it will be eliminated by compiler, so we can not get it in runtime
+```
+
+# reflect2 get/set interface{}
+
+```go
+valType := reflect2.TypeOf(1)
+i := 1
+j := 10
+valType.Set(&i, &j)
+// i will be 10
+```
+
+to get set `type`, always use its pointer `*type`
+
+# reflect2 get/set unsafe.Pointer
+
+```go
+valType := reflect2.TypeOf(1)
+i := 1
+j := 10
+valType.UnsafeSet(unsafe.Pointer(&i), unsafe.Pointer(&j))
+// i will be 10
+```
+
+to get set `type`, always use its pointer `*type`
+
+# benchmark
+
+Benchmark is not necessary for this package. It does nothing actually.
+As it is just a thin wrapper to make go runtime public. 
+Both `reflect2` and `reflect` call same function 
+provided by `runtime` package exposed by go language.
+
+# unsafe safety
+
+Instead of casting `[]byte` to `sliceHeader` in your application using unsafe.
+We can use reflect2 instead. This way, if `sliceHeader` changes in the future,
+only reflect2 need to be upgraded.
+
+reflect2 tries its best to keep the implementation same as reflect (by testing).
\ No newline at end of file
diff --git a/vendor/github.com/modern-go/reflect2/go_above_118.go b/vendor/github.com/modern-go/reflect2/go_above_118.go
new file mode 100644
index 0000000..2b4116f
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/go_above_118.go
@@ -0,0 +1,23 @@
+//+build go1.18
+
+package reflect2
+
+import (
+        "unsafe"
+)
+
+// m escapes into the return value, but the caller of mapiterinit
+// doesn't let the return value escape.
+//go:noescape
+//go:linkname mapiterinit reflect.mapiterinit
+func mapiterinit(rtype unsafe.Pointer, m unsafe.Pointer, it *hiter)
+
+func (type2 *UnsafeMapType) UnsafeIterate(obj unsafe.Pointer) MapIterator {
+        var it hiter
+        mapiterinit(type2.rtype, *(*unsafe.Pointer)(obj), &it)
+        return &UnsafeMapIterator{
+                hiter:      &it,
+                pKeyRType:  type2.pKeyRType,
+                pElemRType: type2.pElemRType,
+        }
+}
\ No newline at end of file
diff --git a/vendor/github.com/modern-go/reflect2/go_above_19.go b/vendor/github.com/modern-go/reflect2/go_above_19.go
new file mode 100644
index 0000000..974f768
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/go_above_19.go
@@ -0,0 +1,17 @@
+//+build go1.9
+
+package reflect2
+
+import (
+        "unsafe"
+)
+
+//go:linkname resolveTypeOff reflect.resolveTypeOff
+func resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer
+
+//go:linkname makemap reflect.makemap
+func makemap(rtype unsafe.Pointer, cap int) (m unsafe.Pointer)
+
+func makeMapWithSize(rtype unsafe.Pointer, cap int) unsafe.Pointer {
+        return makemap(rtype, cap)
+}
diff --git a/vendor/github.com/modern-go/reflect2/go_below_118.go b/vendor/github.com/modern-go/reflect2/go_below_118.go
new file mode 100644
index 0000000..00003db
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/go_below_118.go
@@ -0,0 +1,21 @@
+//+build !go1.18
+
+package reflect2
+
+import (
+        "unsafe"
+)
+
+// m escapes into the return value, but the caller of mapiterinit
+// doesn't let the return value escape.
+//go:noescape
+//go:linkname mapiterinit reflect.mapiterinit
+func mapiterinit(rtype unsafe.Pointer, m unsafe.Pointer) (val *hiter)
+
+func (type2 *UnsafeMapType) UnsafeIterate(obj unsafe.Pointer) MapIterator {
+        return &UnsafeMapIterator{
+                hiter:      mapiterinit(type2.rtype, *(*unsafe.Pointer)(obj)),
+                pKeyRType:  type2.pKeyRType,
+                pElemRType: type2.pElemRType,
+        }
+}
\ No newline at end of file
diff --git a/vendor/github.com/modern-go/reflect2/reflect2.go b/vendor/github.com/modern-go/reflect2/reflect2.go
new file mode 100644
index 0000000..c43c8b9
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/reflect2.go
@@ -0,0 +1,300 @@
+package reflect2
+
+import (
+        "reflect"
+        "runtime"
+        "sync"
+        "unsafe"
+)
+
+type Type interface {
+        Kind() reflect.Kind
+        // New return pointer to data of this type
+        New() interface{}
+        // UnsafeNew return the allocated space pointed by unsafe.Pointer
+        UnsafeNew() unsafe.Pointer
+        // PackEFace cast a unsafe pointer to object represented pointer
+        PackEFace(ptr unsafe.Pointer) interface{}
+        // Indirect dereference object represented pointer to this type
+        Indirect(obj interface{}) interface{}
+        // UnsafeIndirect dereference pointer to this type
+        UnsafeIndirect(ptr unsafe.Pointer) interface{}
+        // Type1 returns reflect.Type
+        Type1() reflect.Type
+        Implements(thatType Type) bool
+        String() string
+        RType() uintptr
+        // interface{} of this type has pointer like behavior
+        LikePtr() bool
+        IsNullable() bool
+        IsNil(obj interface{}) bool
+        UnsafeIsNil(ptr unsafe.Pointer) bool
+        Set(obj interface{}, val interface{})
+        UnsafeSet(ptr unsafe.Pointer, val unsafe.Pointer)
+        AssignableTo(anotherType Type) bool
+}
+
+type ListType interface {
+        Type
+        Elem() Type
+        SetIndex(obj interface{}, index int, elem interface{})
+        UnsafeSetIndex(obj unsafe.Pointer, index int, elem unsafe.Pointer)
+        GetIndex(obj interface{}, index int) interface{}
+        UnsafeGetIndex(obj unsafe.Pointer, index int) unsafe.Pointer
+}
+
+type ArrayType interface {
+        ListType
+        Len() int
+}
+
+type SliceType interface {
+        ListType
+        MakeSlice(length int, cap int) interface{}
+        UnsafeMakeSlice(length int, cap int) unsafe.Pointer
+        Grow(obj interface{}, newLength int)
+        UnsafeGrow(ptr unsafe.Pointer, newLength int)
+        Append(obj interface{}, elem interface{})
+        UnsafeAppend(obj unsafe.Pointer, elem unsafe.Pointer)
+        LengthOf(obj interface{}) int
+        UnsafeLengthOf(ptr unsafe.Pointer) int
+        SetNil(obj interface{})
+        UnsafeSetNil(ptr unsafe.Pointer)
+        Cap(obj interface{}) int
+        UnsafeCap(ptr unsafe.Pointer) int
+}
+
+type StructType interface {
+        Type
+        NumField() int
+        Field(i int) StructField
+        FieldByName(name string) StructField
+        FieldByIndex(index []int) StructField
+        FieldByNameFunc(match func(string) bool) StructField
+}
+
+type StructField interface {
+        Offset() uintptr
+        Name() string
+        PkgPath() string
+        Type() Type
+        Tag() reflect.StructTag
+        Index() []int
+        Anonymous() bool
+        Set(obj interface{}, value interface{})
+        UnsafeSet(obj unsafe.Pointer, value unsafe.Pointer)
+        Get(obj interface{}) interface{}
+        UnsafeGet(obj unsafe.Pointer) unsafe.Pointer
+}
+
+type MapType interface {
+        Type
+        Key() Type
+        Elem() Type
+        MakeMap(cap int) interface{}
+        UnsafeMakeMap(cap int) unsafe.Pointer
+        SetIndex(obj interface{}, key interface{}, elem interface{})
+        UnsafeSetIndex(obj unsafe.Pointer, key unsafe.Pointer, elem unsafe.Pointer)
+        TryGetIndex(obj interface{}, key interface{}) (interface{}, bool)
+        GetIndex(obj interface{}, key interface{}) interface{}
+        UnsafeGetIndex(obj unsafe.Pointer, key unsafe.Pointer) unsafe.Pointer
+        Iterate(obj interface{}) MapIterator
+        UnsafeIterate(obj unsafe.Pointer) MapIterator
+}
+
+type MapIterator interface {
+        HasNext() bool
+        Next() (key interface{}, elem interface{})
+        UnsafeNext() (key unsafe.Pointer, elem unsafe.Pointer)
+}
+
+type PtrType interface {
+        Type
+        Elem() Type
+}
+
+type InterfaceType interface {
+        NumMethod() int
+}
+
+type Config struct {
+        UseSafeImplementation bool
+}
+
+type API interface {
+        TypeOf(obj interface{}) Type
+        Type2(type1 reflect.Type) Type
+}
+
+var ConfigUnsafe = Config{UseSafeImplementation: false}.Froze()
+var ConfigSafe = Config{UseSafeImplementation: true}.Froze()
+
+type frozenConfig struct {
+        useSafeImplementation bool
+        cache                 *sync.Map
+}
+
+func (cfg Config) Froze() *frozenConfig {
+        return &frozenConfig{
+                useSafeImplementation: cfg.UseSafeImplementation,
+                cache:                 new(sync.Map),
+        }
+}
+
+func (cfg *frozenConfig) TypeOf(obj interface{}) Type {
+        cacheKey := uintptr(unpackEFace(obj).rtype)
+        typeObj, found := cfg.cache.Load(cacheKey)
+        if found {
+                return typeObj.(Type)
+        }
+        return cfg.Type2(reflect.TypeOf(obj))
+}
+
+func (cfg *frozenConfig) Type2(type1 reflect.Type) Type {
+        if type1 == nil {
+                return nil
+        }
+        cacheKey := uintptr(unpackEFace(type1).data)
+        typeObj, found := cfg.cache.Load(cacheKey)
+        if found {
+                return typeObj.(Type)
+        }
+        type2 := cfg.wrapType(type1)
+        cfg.cache.Store(cacheKey, type2)
+        return type2
+}
+
+func (cfg *frozenConfig) wrapType(type1 reflect.Type) Type {
+        safeType := safeType{Type: type1, cfg: cfg}
+        switch type1.Kind() {
+        case reflect.Struct:
+                if cfg.useSafeImplementation {
+                        return &safeStructType{safeType}
+                }
+                return newUnsafeStructType(cfg, type1)
+        case reflect.Array:
+                if cfg.useSafeImplementation {
+                        return &safeSliceType{safeType}
+                }
+                return newUnsafeArrayType(cfg, type1)
+        case reflect.Slice:
+                if cfg.useSafeImplementation {
+                        return &safeSliceType{safeType}
+                }
+                return newUnsafeSliceType(cfg, type1)
+        case reflect.Map:
+                if cfg.useSafeImplementation {
+                        return &safeMapType{safeType}
+                }
+                return newUnsafeMapType(cfg, type1)
+        case reflect.Ptr, reflect.Chan, reflect.Func:
+                if cfg.useSafeImplementation {
+                        return &safeMapType{safeType}
+                }
+                return newUnsafePtrType(cfg, type1)
+        case reflect.Interface:
+                if cfg.useSafeImplementation {
+                        return &safeMapType{safeType}
+                }
+                if type1.NumMethod() == 0 {
+                        return newUnsafeEFaceType(cfg, type1)
+                }
+                return newUnsafeIFaceType(cfg, type1)
+        default:
+                if cfg.useSafeImplementation {
+                        return &safeType
+                }
+                return newUnsafeType(cfg, type1)
+        }
+}
+
+func TypeOf(obj interface{}) Type {
+        return ConfigUnsafe.TypeOf(obj)
+}
+
+func TypeOfPtr(obj interface{}) PtrType {
+        return TypeOf(obj).(PtrType)
+}
+
+func Type2(type1 reflect.Type) Type {
+        if type1 == nil {
+                return nil
+        }
+        return ConfigUnsafe.Type2(type1)
+}
+
+func PtrTo(typ Type) Type {
+        return Type2(reflect.PtrTo(typ.Type1()))
+}
+
+func PtrOf(obj interface{}) unsafe.Pointer {
+        return unpackEFace(obj).data
+}
+
+func RTypeOf(obj interface{}) uintptr {
+        return uintptr(unpackEFace(obj).rtype)
+}
+
+func IsNil(obj interface{}) bool {
+        if obj == nil {
+                return true
+        }
+        return unpackEFace(obj).data == nil
+}
+
+func IsNullable(kind reflect.Kind) bool {
+        switch kind {
+        case reflect.Ptr, reflect.Map, reflect.Chan, reflect.Func, reflect.Slice, reflect.Interface:
+                return true
+        }
+        return false
+}
+
+func likePtrKind(kind reflect.Kind) bool {
+        switch kind {
+        case reflect.Ptr, reflect.Map, reflect.Chan, reflect.Func:
+                return true
+        }
+        return false
+}
+
+func likePtrType(typ reflect.Type) bool {
+        if likePtrKind(typ.Kind()) {
+                return true
+        }
+        if typ.Kind() == reflect.Struct {
+                if typ.NumField() != 1 {
+                        return false
+                }
+                return likePtrType(typ.Field(0).Type)
+        }
+        if typ.Kind() == reflect.Array {
+                if typ.Len() != 1 {
+                        return false
+                }
+                return likePtrType(typ.Elem())
+        }
+        return false
+}
+
+// NoEscape hides a pointer from escape analysis.  noescape is
+// the identity function but escape analysis doesn't think the
+// output depends on the input.  noescape is inlined and currently
+// compiles down to zero instructions.
+// USE CAREFULLY!
+//go:nosplit
+func NoEscape(p unsafe.Pointer) unsafe.Pointer {
+        x := uintptr(p)
+        return unsafe.Pointer(x ^ 0)
+}
+
+func UnsafeCastString(str string) []byte {
+        bytes := make([]byte, 0)
+        stringHeader := (*reflect.StringHeader)(unsafe.Pointer(&str))
+        sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&bytes))
+        sliceHeader.Data = stringHeader.Data
+        sliceHeader.Cap = stringHeader.Len
+        sliceHeader.Len = stringHeader.Len
+        runtime.KeepAlive(str)
+        return bytes
+}
diff --git a/vendor/github.com/modern-go/reflect2/reflect2_amd64.s b/vendor/github.com/modern-go/reflect2/reflect2_amd64.s
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/reflect2_amd64.s
diff --git a/vendor/github.com/modern-go/reflect2/reflect2_kind.go b/vendor/github.com/modern-go/reflect2/reflect2_kind.go
new file mode 100644
index 0000000..62f299e
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/reflect2_kind.go
@@ -0,0 +1,30 @@
+package reflect2
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+// DefaultTypeOfKind return the non aliased default type for the kind
+func DefaultTypeOfKind(kind reflect.Kind) Type {
+        return kindTypes[kind]
+}
+
+var kindTypes = map[reflect.Kind]Type{
+        reflect.Bool:          TypeOf(true),
+        reflect.Uint8:         TypeOf(uint8(0)),
+        reflect.Int8:          TypeOf(int8(0)),
+        reflect.Uint16:        TypeOf(uint16(0)),
+        reflect.Int16:         TypeOf(int16(0)),
+        reflect.Uint32:        TypeOf(uint32(0)),
+        reflect.Int32:         TypeOf(int32(0)),
+        reflect.Uint64:        TypeOf(uint64(0)),
+        reflect.Int64:         TypeOf(int64(0)),
+        reflect.Uint:          TypeOf(uint(0)),
+        reflect.Int:           TypeOf(int(0)),
+        reflect.Float32:       TypeOf(float32(0)),
+        reflect.Float64:       TypeOf(float64(0)),
+        reflect.Uintptr:       TypeOf(uintptr(0)),
+        reflect.String:        TypeOf(""),
+        reflect.UnsafePointer: TypeOf(unsafe.Pointer(nil)),
+}
diff --git a/vendor/github.com/modern-go/reflect2/relfect2_386.s b/vendor/github.com/modern-go/reflect2/relfect2_386.s
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/relfect2_386.s
diff --git a/vendor/github.com/modern-go/reflect2/relfect2_amd64p32.s b/vendor/github.com/modern-go/reflect2/relfect2_amd64p32.s
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/relfect2_amd64p32.s
diff --git a/vendor/github.com/modern-go/reflect2/relfect2_arm.s b/vendor/github.com/modern-go/reflect2/relfect2_arm.s
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/relfect2_arm.s
diff --git a/vendor/github.com/modern-go/reflect2/relfect2_arm64.s b/vendor/github.com/modern-go/reflect2/relfect2_arm64.s
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/relfect2_arm64.s
diff --git a/vendor/github.com/modern-go/reflect2/relfect2_mips64x.s b/vendor/github.com/modern-go/reflect2/relfect2_mips64x.s
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/relfect2_mips64x.s
diff --git a/vendor/github.com/modern-go/reflect2/relfect2_mipsx.s b/vendor/github.com/modern-go/reflect2/relfect2_mipsx.s
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/relfect2_mipsx.s
diff --git a/vendor/github.com/modern-go/reflect2/relfect2_ppc64x.s b/vendor/github.com/modern-go/reflect2/relfect2_ppc64x.s
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/relfect2_ppc64x.s
diff --git a/vendor/github.com/modern-go/reflect2/relfect2_s390x.s b/vendor/github.com/modern-go/reflect2/relfect2_s390x.s
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/relfect2_s390x.s
diff --git a/vendor/github.com/modern-go/reflect2/safe_field.go b/vendor/github.com/modern-go/reflect2/safe_field.go
new file mode 100644
index 0000000..d4ba1f4
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/safe_field.go
@@ -0,0 +1,58 @@
+package reflect2
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type safeField struct {
+        reflect.StructField
+}
+
+func (field *safeField) Offset() uintptr {
+        return field.StructField.Offset
+}
+
+func (field *safeField) Name() string {
+        return field.StructField.Name
+}
+
+func (field *safeField) PkgPath() string {
+        return field.StructField.PkgPath
+}
+
+func (field *safeField) Type() Type {
+        panic("not implemented")
+}
+
+func (field *safeField) Tag() reflect.StructTag {
+        return field.StructField.Tag
+}
+
+func (field *safeField) Index() []int {
+        return field.StructField.Index
+}
+
+func (field *safeField) Anonymous() bool {
+        return field.StructField.Anonymous
+}
+
+func (field *safeField) Set(obj interface{}, value interface{}) {
+        val := reflect.ValueOf(obj).Elem()
+        val.FieldByIndex(field.Index()).Set(reflect.ValueOf(value).Elem())
+}
+
+func (field *safeField) UnsafeSet(obj unsafe.Pointer, value unsafe.Pointer) {
+        panic("unsafe operation is not supported")
+}
+
+func (field *safeField) Get(obj interface{}) interface{} {
+        val := reflect.ValueOf(obj).Elem().FieldByIndex(field.Index())
+        ptr := reflect.New(val.Type())
+        ptr.Elem().Set(val)
+        return ptr.Interface()
+}
+
+func (field *safeField) UnsafeGet(obj unsafe.Pointer) unsafe.Pointer {
+        panic("does not support unsafe operation")
+}
diff --git a/vendor/github.com/modern-go/reflect2/safe_map.go b/vendor/github.com/modern-go/reflect2/safe_map.go
new file mode 100644
index 0000000..8836220
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/safe_map.go
@@ -0,0 +1,101 @@
+package reflect2
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type safeMapType struct {
+        safeType
+}
+
+func (type2 *safeMapType) Key() Type {
+        return type2.safeType.cfg.Type2(type2.Type.Key())
+}
+
+func (type2 *safeMapType) MakeMap(cap int) interface{} {
+        ptr := reflect.New(type2.Type)
+        ptr.Elem().Set(reflect.MakeMap(type2.Type))
+        return ptr.Interface()
+}
+
+func (type2 *safeMapType) UnsafeMakeMap(cap int) unsafe.Pointer {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeMapType) SetIndex(obj interface{}, key interface{}, elem interface{}) {
+        keyVal := reflect.ValueOf(key)
+        elemVal := reflect.ValueOf(elem)
+        val := reflect.ValueOf(obj)
+        val.Elem().SetMapIndex(keyVal.Elem(), elemVal.Elem())
+}
+
+func (type2 *safeMapType) UnsafeSetIndex(obj unsafe.Pointer, key unsafe.Pointer, elem unsafe.Pointer) {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeMapType) TryGetIndex(obj interface{}, key interface{}) (interface{}, bool) {
+        keyVal := reflect.ValueOf(key)
+        if key == nil {
+                keyVal = reflect.New(type2.Type.Key()).Elem()
+        }
+        val := reflect.ValueOf(obj).MapIndex(keyVal)
+        if !val.IsValid() {
+                return nil, false
+        }
+        return val.Interface(), true
+}
+
+func (type2 *safeMapType) GetIndex(obj interface{}, key interface{}) interface{} {
+        val := reflect.ValueOf(obj).Elem()
+        keyVal := reflect.ValueOf(key).Elem()
+        elemVal := val.MapIndex(keyVal)
+        if !elemVal.IsValid() {
+                ptr := reflect.New(reflect.PtrTo(val.Type().Elem()))
+                return ptr.Elem().Interface()
+        }
+        ptr := reflect.New(elemVal.Type())
+        ptr.Elem().Set(elemVal)
+        return ptr.Interface()
+}
+
+func (type2 *safeMapType) UnsafeGetIndex(obj unsafe.Pointer, key unsafe.Pointer) unsafe.Pointer {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeMapType) Iterate(obj interface{}) MapIterator {
+        m := reflect.ValueOf(obj).Elem()
+        return &safeMapIterator{
+                m:    m,
+                keys: m.MapKeys(),
+        }
+}
+
+func (type2 *safeMapType) UnsafeIterate(obj unsafe.Pointer) MapIterator {
+        panic("does not support unsafe operation")
+}
+
+type safeMapIterator struct {
+        i    int
+        m    reflect.Value
+        keys []reflect.Value
+}
+
+func (iter *safeMapIterator) HasNext() bool {
+        return iter.i != len(iter.keys)
+}
+
+func (iter *safeMapIterator) Next() (interface{}, interface{}) {
+        key := iter.keys[iter.i]
+        elem := iter.m.MapIndex(key)
+        iter.i += 1
+        keyPtr := reflect.New(key.Type())
+        keyPtr.Elem().Set(key)
+        elemPtr := reflect.New(elem.Type())
+        elemPtr.Elem().Set(elem)
+        return keyPtr.Interface(), elemPtr.Interface()
+}
+
+func (iter *safeMapIterator) UnsafeNext() (unsafe.Pointer, unsafe.Pointer) {
+        panic("does not support unsafe operation")
+}
diff --git a/vendor/github.com/modern-go/reflect2/safe_slice.go b/vendor/github.com/modern-go/reflect2/safe_slice.go
new file mode 100644
index 0000000..bcce6fd
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/safe_slice.go
@@ -0,0 +1,92 @@
+package reflect2
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type safeSliceType struct {
+        safeType
+}
+
+func (type2 *safeSliceType) SetIndex(obj interface{}, index int, value interface{}) {
+        val := reflect.ValueOf(obj).Elem()
+        elem := reflect.ValueOf(value).Elem()
+        val.Index(index).Set(elem)
+}
+
+func (type2 *safeSliceType) UnsafeSetIndex(obj unsafe.Pointer, index int, value unsafe.Pointer) {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeSliceType) GetIndex(obj interface{}, index int) interface{} {
+        val := reflect.ValueOf(obj).Elem()
+        elem := val.Index(index)
+        ptr := reflect.New(elem.Type())
+        ptr.Elem().Set(elem)
+        return ptr.Interface()
+}
+
+func (type2 *safeSliceType) UnsafeGetIndex(obj unsafe.Pointer, index int) unsafe.Pointer {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeSliceType) MakeSlice(length int, cap int) interface{} {
+        val := reflect.MakeSlice(type2.Type, length, cap)
+        ptr := reflect.New(val.Type())
+        ptr.Elem().Set(val)
+        return ptr.Interface()
+}
+
+func (type2 *safeSliceType) UnsafeMakeSlice(length int, cap int) unsafe.Pointer {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeSliceType) Grow(obj interface{}, newLength int) {
+        oldCap := type2.Cap(obj)
+        oldSlice := reflect.ValueOf(obj).Elem()
+        delta := newLength - oldCap
+        deltaVals := make([]reflect.Value, delta)
+        newSlice := reflect.Append(oldSlice, deltaVals...)
+        oldSlice.Set(newSlice)
+}
+
+func (type2 *safeSliceType) UnsafeGrow(ptr unsafe.Pointer, newLength int) {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeSliceType) Append(obj interface{}, elem interface{}) {
+        val := reflect.ValueOf(obj).Elem()
+        elemVal := reflect.ValueOf(elem).Elem()
+        newVal := reflect.Append(val, elemVal)
+        val.Set(newVal)
+}
+
+func (type2 *safeSliceType) UnsafeAppend(obj unsafe.Pointer, elem unsafe.Pointer) {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeSliceType) SetNil(obj interface{}) {
+        val := reflect.ValueOf(obj).Elem()
+        val.Set(reflect.Zero(val.Type()))
+}
+
+func (type2 *safeSliceType) UnsafeSetNil(ptr unsafe.Pointer) {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeSliceType) LengthOf(obj interface{}) int {
+        return reflect.ValueOf(obj).Elem().Len()
+}
+
+func (type2 *safeSliceType) UnsafeLengthOf(ptr unsafe.Pointer) int {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeSliceType) Cap(obj interface{}) int {
+        return reflect.ValueOf(obj).Elem().Cap()
+}
+
+func (type2 *safeSliceType) UnsafeCap(ptr unsafe.Pointer) int {
+        panic("does not support unsafe operation")
+}
diff --git a/vendor/github.com/modern-go/reflect2/safe_struct.go b/vendor/github.com/modern-go/reflect2/safe_struct.go
new file mode 100644
index 0000000..e5fb9b3
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/safe_struct.go
@@ -0,0 +1,29 @@
+package reflect2
+
+type safeStructType struct {
+        safeType
+}
+
+func (type2 *safeStructType) FieldByName(name string) StructField {
+        field, found := type2.Type.FieldByName(name)
+        if !found {
+                panic("field " + name + " not found")
+        }
+        return &safeField{StructField: field}
+}
+
+func (type2 *safeStructType) Field(i int) StructField {
+        return &safeField{StructField: type2.Type.Field(i)}
+}
+
+func (type2 *safeStructType) FieldByIndex(index []int) StructField {
+        return &safeField{StructField: type2.Type.FieldByIndex(index)}
+}
+
+func (type2 *safeStructType) FieldByNameFunc(match func(string) bool) StructField {
+        field, found := type2.Type.FieldByNameFunc(match)
+        if !found {
+                panic("field match condition not found in " + type2.Type.String())
+        }
+        return &safeField{StructField: field}
+}
diff --git a/vendor/github.com/modern-go/reflect2/safe_type.go b/vendor/github.com/modern-go/reflect2/safe_type.go
new file mode 100644
index 0000000..ee4e7bb
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/safe_type.go
@@ -0,0 +1,78 @@
+package reflect2
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type safeType struct {
+        reflect.Type
+        cfg *frozenConfig
+}
+
+func (type2 *safeType) New() interface{} {
+        return reflect.New(type2.Type).Interface()
+}
+
+func (type2 *safeType) UnsafeNew() unsafe.Pointer {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeType) Elem() Type {
+        return type2.cfg.Type2(type2.Type.Elem())
+}
+
+func (type2 *safeType) Type1() reflect.Type {
+        return type2.Type
+}
+
+func (type2 *safeType) PackEFace(ptr unsafe.Pointer) interface{} {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeType) Implements(thatType Type) bool {
+        return type2.Type.Implements(thatType.Type1())
+}
+
+func (type2 *safeType) RType() uintptr {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeType) Indirect(obj interface{}) interface{} {
+        return reflect.Indirect(reflect.ValueOf(obj)).Interface()
+}
+
+func (type2 *safeType) UnsafeIndirect(ptr unsafe.Pointer) interface{} {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeType) LikePtr() bool {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeType) IsNullable() bool {
+        return IsNullable(type2.Kind())
+}
+
+func (type2 *safeType) IsNil(obj interface{}) bool {
+        if obj == nil {
+                return true
+        }
+        return reflect.ValueOf(obj).Elem().IsNil()
+}
+
+func (type2 *safeType) UnsafeIsNil(ptr unsafe.Pointer) bool {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeType) Set(obj interface{}, val interface{}) {
+        reflect.ValueOf(obj).Elem().Set(reflect.ValueOf(val).Elem())
+}
+
+func (type2 *safeType) UnsafeSet(ptr unsafe.Pointer, val unsafe.Pointer) {
+        panic("does not support unsafe operation")
+}
+
+func (type2 *safeType) AssignableTo(anotherType Type) bool {
+        return type2.Type1().AssignableTo(anotherType.Type1())
+}
diff --git a/vendor/github.com/modern-go/reflect2/type_map.go b/vendor/github.com/modern-go/reflect2/type_map.go
new file mode 100644
index 0000000..4b13c31
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/type_map.go
@@ -0,0 +1,70 @@
+// +build !gccgo
+
+package reflect2
+
+import (
+        "reflect"
+        "sync"
+        "unsafe"
+)
+
+// typelinks2 for 1.7 ~
+//go:linkname typelinks2 reflect.typelinks
+func typelinks2() (sections []unsafe.Pointer, offset [][]int32)
+
+// initOnce guards initialization of types and packages
+var initOnce sync.Once
+
+var types map[string]reflect.Type
+var packages map[string]map[string]reflect.Type
+
+// discoverTypes initializes types and packages
+func discoverTypes() {
+        types = make(map[string]reflect.Type)
+        packages = make(map[string]map[string]reflect.Type)
+
+        loadGoTypes()
+}
+
+func loadGoTypes() {
+        var obj interface{} = reflect.TypeOf(0)
+        sections, offset := typelinks2()
+        for i, offs := range offset {
+                rodata := sections[i]
+                for _, off := range offs {
+                        (*emptyInterface)(unsafe.Pointer(&obj)).word = resolveTypeOff(unsafe.Pointer(rodata), off)
+                        typ := obj.(reflect.Type)
+                        if typ.Kind() == reflect.Ptr && typ.Elem().Kind() == reflect.Struct {
+                                loadedType := typ.Elem()
+                                pkgTypes := packages[loadedType.PkgPath()]
+                                if pkgTypes == nil {
+                                        pkgTypes = map[string]reflect.Type{}
+                                        packages[loadedType.PkgPath()] = pkgTypes
+                                }
+                                types[loadedType.String()] = loadedType
+                                pkgTypes[loadedType.Name()] = loadedType
+                        }
+                }
+        }
+}
+
+type emptyInterface struct {
+        typ  unsafe.Pointer
+        word unsafe.Pointer
+}
+
+// TypeByName return the type by its name, just like Class.forName in java
+func TypeByName(typeName string) Type {
+        initOnce.Do(discoverTypes)
+        return Type2(types[typeName])
+}
+
+// TypeByPackageName return the type by its package and name
+func TypeByPackageName(pkgPath string, name string) Type {
+        initOnce.Do(discoverTypes)
+        pkgTypes := packages[pkgPath]
+        if pkgTypes == nil {
+                return nil
+        }
+        return Type2(pkgTypes[name])
+}
diff --git a/vendor/github.com/modern-go/reflect2/unsafe_array.go b/vendor/github.com/modern-go/reflect2/unsafe_array.go
new file mode 100644
index 0000000..76cbdba
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/unsafe_array.go
@@ -0,0 +1,65 @@
+package reflect2
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type UnsafeArrayType struct {
+        unsafeType
+        elemRType  unsafe.Pointer
+        pElemRType unsafe.Pointer
+        elemSize   uintptr
+        likePtr    bool
+}
+
+func newUnsafeArrayType(cfg *frozenConfig, type1 reflect.Type) *UnsafeArrayType {
+        return &UnsafeArrayType{
+                unsafeType: *newUnsafeType(cfg, type1),
+                elemRType:  unpackEFace(type1.Elem()).data,
+                pElemRType: unpackEFace(reflect.PtrTo(type1.Elem())).data,
+                elemSize:   type1.Elem().Size(),
+                likePtr:    likePtrType(type1),
+        }
+}
+
+func (type2 *UnsafeArrayType) LikePtr() bool {
+        return type2.likePtr
+}
+
+func (type2 *UnsafeArrayType) Indirect(obj interface{}) interface{} {
+        objEFace := unpackEFace(obj)
+        assertType("Type.Indirect argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeIndirect(objEFace.data)
+}
+
+func (type2 *UnsafeArrayType) UnsafeIndirect(ptr unsafe.Pointer) interface{} {
+        if type2.likePtr {
+                return packEFace(type2.rtype, *(*unsafe.Pointer)(ptr))
+        }
+        return packEFace(type2.rtype, ptr)
+}
+
+func (type2 *UnsafeArrayType) SetIndex(obj interface{}, index int, elem interface{}) {
+        objEFace := unpackEFace(obj)
+        assertType("ArrayType.SetIndex argument 1", type2.ptrRType, objEFace.rtype)
+        elemEFace := unpackEFace(elem)
+        assertType("ArrayType.SetIndex argument 3", type2.pElemRType, elemEFace.rtype)
+        type2.UnsafeSetIndex(objEFace.data, index, elemEFace.data)
+}
+
+func (type2 *UnsafeArrayType) UnsafeSetIndex(obj unsafe.Pointer, index int, elem unsafe.Pointer) {
+        elemPtr := arrayAt(obj, index, type2.elemSize, "i < s.Len")
+        typedmemmove(type2.elemRType, elemPtr, elem)
+}
+
+func (type2 *UnsafeArrayType) GetIndex(obj interface{}, index int) interface{} {
+        objEFace := unpackEFace(obj)
+        assertType("ArrayType.GetIndex argument 1", type2.ptrRType, objEFace.rtype)
+        elemPtr := type2.UnsafeGetIndex(objEFace.data, index)
+        return packEFace(type2.pElemRType, elemPtr)
+}
+
+func (type2 *UnsafeArrayType) UnsafeGetIndex(obj unsafe.Pointer, index int) unsafe.Pointer {
+        return arrayAt(obj, index, type2.elemSize, "i < s.Len")
+}
diff --git a/vendor/github.com/modern-go/reflect2/unsafe_eface.go b/vendor/github.com/modern-go/reflect2/unsafe_eface.go
new file mode 100644
index 0000000..805010f
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/unsafe_eface.go
@@ -0,0 +1,59 @@
+package reflect2
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type eface struct {
+        rtype unsafe.Pointer
+        data  unsafe.Pointer
+}
+
+func unpackEFace(obj interface{}) *eface {
+        return (*eface)(unsafe.Pointer(&obj))
+}
+
+func packEFace(rtype unsafe.Pointer, data unsafe.Pointer) interface{} {
+        var i interface{}
+        e := (*eface)(unsafe.Pointer(&i))
+        e.rtype = rtype
+        e.data = data
+        return i
+}
+
+type UnsafeEFaceType struct {
+        unsafeType
+}
+
+func newUnsafeEFaceType(cfg *frozenConfig, type1 reflect.Type) *UnsafeEFaceType {
+        return &UnsafeEFaceType{
+                unsafeType: *newUnsafeType(cfg, type1),
+        }
+}
+
+func (type2 *UnsafeEFaceType) IsNil(obj interface{}) bool {
+        if obj == nil {
+                return true
+        }
+        objEFace := unpackEFace(obj)
+        assertType("Type.IsNil argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeIsNil(objEFace.data)
+}
+
+func (type2 *UnsafeEFaceType) UnsafeIsNil(ptr unsafe.Pointer) bool {
+        if ptr == nil {
+                return true
+        }
+        return unpackEFace(*(*interface{})(ptr)).data == nil
+}
+
+func (type2 *UnsafeEFaceType) Indirect(obj interface{}) interface{} {
+        objEFace := unpackEFace(obj)
+        assertType("Type.Indirect argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeIndirect(objEFace.data)
+}
+
+func (type2 *UnsafeEFaceType) UnsafeIndirect(ptr unsafe.Pointer) interface{} {
+        return *(*interface{})(ptr)
+}
diff --git a/vendor/github.com/modern-go/reflect2/unsafe_field.go b/vendor/github.com/modern-go/reflect2/unsafe_field.go
new file mode 100644
index 0000000..5eb5313
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/unsafe_field.go
@@ -0,0 +1,74 @@
+package reflect2
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type UnsafeStructField struct {
+        reflect.StructField
+        structType *UnsafeStructType
+        rtype      unsafe.Pointer
+        ptrRType   unsafe.Pointer
+}
+
+func newUnsafeStructField(structType *UnsafeStructType, structField reflect.StructField) *UnsafeStructField {
+        return &UnsafeStructField{
+                StructField: structField,
+                rtype:       unpackEFace(structField.Type).data,
+                ptrRType:    unpackEFace(reflect.PtrTo(structField.Type)).data,
+                structType:  structType,
+        }
+}
+
+func (field *UnsafeStructField) Offset() uintptr {
+        return field.StructField.Offset
+}
+
+func (field *UnsafeStructField) Name() string {
+        return field.StructField.Name
+}
+
+func (field *UnsafeStructField) PkgPath() string {
+        return field.StructField.PkgPath
+}
+
+func (field *UnsafeStructField) Type() Type {
+        return field.structType.cfg.Type2(field.StructField.Type)
+}
+
+func (field *UnsafeStructField) Tag() reflect.StructTag {
+        return field.StructField.Tag
+}
+
+func (field *UnsafeStructField) Index() []int {
+        return field.StructField.Index
+}
+
+func (field *UnsafeStructField) Anonymous() bool {
+        return field.StructField.Anonymous
+}
+
+func (field *UnsafeStructField) Set(obj interface{}, value interface{}) {
+        objEFace := unpackEFace(obj)
+        assertType("StructField.SetIndex argument 1", field.structType.ptrRType, objEFace.rtype)
+        valueEFace := unpackEFace(value)
+        assertType("StructField.SetIndex argument 2", field.ptrRType, valueEFace.rtype)
+        field.UnsafeSet(objEFace.data, valueEFace.data)
+}
+
+func (field *UnsafeStructField) UnsafeSet(obj unsafe.Pointer, value unsafe.Pointer) {
+        fieldPtr := add(obj, field.StructField.Offset, "same as non-reflect &v.field")
+        typedmemmove(field.rtype, fieldPtr, value)
+}
+
+func (field *UnsafeStructField) Get(obj interface{}) interface{} {
+        objEFace := unpackEFace(obj)
+        assertType("StructField.GetIndex argument 1", field.structType.ptrRType, objEFace.rtype)
+        value := field.UnsafeGet(objEFace.data)
+        return packEFace(field.ptrRType, value)
+}
+
+func (field *UnsafeStructField) UnsafeGet(obj unsafe.Pointer) unsafe.Pointer {
+        return add(obj, field.StructField.Offset, "same as non-reflect &v.field")
+}
diff --git a/vendor/github.com/modern-go/reflect2/unsafe_iface.go b/vendor/github.com/modern-go/reflect2/unsafe_iface.go
new file mode 100644
index 0000000..b601955
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/unsafe_iface.go
@@ -0,0 +1,64 @@
+package reflect2
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type iface struct {
+        itab *itab
+        data unsafe.Pointer
+}
+
+type itab struct {
+        ignore unsafe.Pointer
+        rtype  unsafe.Pointer
+}
+
+func IFaceToEFace(ptr unsafe.Pointer) interface{} {
+        iface := (*iface)(ptr)
+        if iface.itab == nil {
+                return nil
+        }
+        return packEFace(iface.itab.rtype, iface.data)
+}
+
+type UnsafeIFaceType struct {
+        unsafeType
+}
+
+func newUnsafeIFaceType(cfg *frozenConfig, type1 reflect.Type) *UnsafeIFaceType {
+        return &UnsafeIFaceType{
+                unsafeType: *newUnsafeType(cfg, type1),
+        }
+}
+
+func (type2 *UnsafeIFaceType) Indirect(obj interface{}) interface{} {
+        objEFace := unpackEFace(obj)
+        assertType("Type.Indirect argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeIndirect(objEFace.data)
+}
+
+func (type2 *UnsafeIFaceType) UnsafeIndirect(ptr unsafe.Pointer) interface{} {
+        return IFaceToEFace(ptr)
+}
+
+func (type2 *UnsafeIFaceType) IsNil(obj interface{}) bool {
+        if obj == nil {
+                return true
+        }
+        objEFace := unpackEFace(obj)
+        assertType("Type.IsNil argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeIsNil(objEFace.data)
+}
+
+func (type2 *UnsafeIFaceType) UnsafeIsNil(ptr unsafe.Pointer) bool {
+        if ptr == nil {
+                return true
+        }
+        iface := (*iface)(ptr)
+        if iface.itab == nil {
+                return true
+        }
+        return false
+}
diff --git a/vendor/github.com/modern-go/reflect2/unsafe_link.go b/vendor/github.com/modern-go/reflect2/unsafe_link.go
new file mode 100644
index 0000000..b49f614
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/unsafe_link.go
@@ -0,0 +1,76 @@
+package reflect2
+
+import "unsafe"
+
+//go:linkname unsafe_New reflect.unsafe_New
+func unsafe_New(rtype unsafe.Pointer) unsafe.Pointer
+
+//go:linkname typedmemmove reflect.typedmemmove
+func typedmemmove(rtype unsafe.Pointer, dst, src unsafe.Pointer)
+
+//go:linkname unsafe_NewArray reflect.unsafe_NewArray
+func unsafe_NewArray(rtype unsafe.Pointer, length int) unsafe.Pointer
+
+// typedslicecopy copies a slice of elemType values from src to dst,
+// returning the number of elements copied.
+//go:linkname typedslicecopy reflect.typedslicecopy
+//go:noescape
+func typedslicecopy(elemType unsafe.Pointer, dst, src sliceHeader) int
+
+//go:linkname mapassign reflect.mapassign
+//go:noescape
+func mapassign(rtype unsafe.Pointer, m unsafe.Pointer, key unsafe.Pointer, val unsafe.Pointer)
+
+//go:linkname mapaccess reflect.mapaccess
+//go:noescape
+func mapaccess(rtype unsafe.Pointer, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer)
+
+//go:noescape
+//go:linkname mapiternext reflect.mapiternext
+func mapiternext(it *hiter)
+
+//go:linkname ifaceE2I reflect.ifaceE2I
+func ifaceE2I(rtype unsafe.Pointer, src interface{}, dst unsafe.Pointer)
+
+// A hash iteration structure.
+// If you modify hiter, also change cmd/internal/gc/reflect.go to indicate
+// the layout of this structure.
+type hiter struct {
+        key         unsafe.Pointer
+        value       unsafe.Pointer
+        t           unsafe.Pointer
+        h           unsafe.Pointer
+        buckets     unsafe.Pointer
+        bptr        unsafe.Pointer
+        overflow    *[]unsafe.Pointer
+        oldoverflow *[]unsafe.Pointer
+        startBucket uintptr
+        offset      uint8
+        wrapped     bool
+        B           uint8
+        i           uint8
+        bucket      uintptr
+        checkBucket uintptr
+}
+
+// add returns p+x.
+//
+// The whySafe string is ignored, so that the function still inlines
+// as efficiently as p+x, but all call sites should use the string to
+// record why the addition is safe, which is to say why the addition
+// does not cause x to advance to the very end of p's allocation
+// and therefore point incorrectly at the next block in memory.
+func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
+        return unsafe.Pointer(uintptr(p) + x)
+}
+
+// arrayAt returns the i-th element of p,
+// an array whose elements are eltSize bytes wide.
+// The array pointed at by p must have at least i+1 elements:
+// it is invalid (but impossible to check here) to pass i >= len,
+// because then the result will point outside the array.
+// whySafe must explain why i < len. (Passing "i < len" is fine;
+// the benefit is to surface this assumption at the call site.)
+func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Pointer {
+        return add(p, uintptr(i)*eltSize, "i < len")
+}
diff --git a/vendor/github.com/modern-go/reflect2/unsafe_map.go b/vendor/github.com/modern-go/reflect2/unsafe_map.go
new file mode 100644
index 0000000..37872da
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/unsafe_map.go
@@ -0,0 +1,130 @@
+package reflect2
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type UnsafeMapType struct {
+        unsafeType
+        pKeyRType  unsafe.Pointer
+        pElemRType unsafe.Pointer
+}
+
+func newUnsafeMapType(cfg *frozenConfig, type1 reflect.Type) MapType {
+        return &UnsafeMapType{
+                unsafeType: *newUnsafeType(cfg, type1),
+                pKeyRType:  unpackEFace(reflect.PtrTo(type1.Key())).data,
+                pElemRType: unpackEFace(reflect.PtrTo(type1.Elem())).data,
+        }
+}
+
+func (type2 *UnsafeMapType) IsNil(obj interface{}) bool {
+        if obj == nil {
+                return true
+        }
+        objEFace := unpackEFace(obj)
+        assertType("Type.IsNil argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeIsNil(objEFace.data)
+}
+
+func (type2 *UnsafeMapType) UnsafeIsNil(ptr unsafe.Pointer) bool {
+        if ptr == nil {
+                return true
+        }
+        return *(*unsafe.Pointer)(ptr) == nil
+}
+
+func (type2 *UnsafeMapType) LikePtr() bool {
+        return true
+}
+
+func (type2 *UnsafeMapType) Indirect(obj interface{}) interface{} {
+        objEFace := unpackEFace(obj)
+        assertType("MapType.Indirect argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeIndirect(objEFace.data)
+}
+
+func (type2 *UnsafeMapType) UnsafeIndirect(ptr unsafe.Pointer) interface{} {
+        return packEFace(type2.rtype, *(*unsafe.Pointer)(ptr))
+}
+
+func (type2 *UnsafeMapType) Key() Type {
+        return type2.cfg.Type2(type2.Type.Key())
+}
+
+func (type2 *UnsafeMapType) MakeMap(cap int) interface{} {
+        return packEFace(type2.ptrRType, type2.UnsafeMakeMap(cap))
+}
+
+func (type2 *UnsafeMapType) UnsafeMakeMap(cap int) unsafe.Pointer {
+        m := makeMapWithSize(type2.rtype, cap)
+        return unsafe.Pointer(&m)
+}
+
+func (type2 *UnsafeMapType) SetIndex(obj interface{}, key interface{}, elem interface{}) {
+        objEFace := unpackEFace(obj)
+        assertType("MapType.SetIndex argument 1", type2.ptrRType, objEFace.rtype)
+        keyEFace := unpackEFace(key)
+        assertType("MapType.SetIndex argument 2", type2.pKeyRType, keyEFace.rtype)
+        elemEFace := unpackEFace(elem)
+        assertType("MapType.SetIndex argument 3", type2.pElemRType, elemEFace.rtype)
+        type2.UnsafeSetIndex(objEFace.data, keyEFace.data, elemEFace.data)
+}
+
+func (type2 *UnsafeMapType) UnsafeSetIndex(obj unsafe.Pointer, key unsafe.Pointer, elem unsafe.Pointer) {
+        mapassign(type2.rtype, *(*unsafe.Pointer)(obj), key, elem)
+}
+
+func (type2 *UnsafeMapType) TryGetIndex(obj interface{}, key interface{}) (interface{}, bool) {
+        objEFace := unpackEFace(obj)
+        assertType("MapType.TryGetIndex argument 1", type2.ptrRType, objEFace.rtype)
+        keyEFace := unpackEFace(key)
+        assertType("MapType.TryGetIndex argument 2", type2.pKeyRType, keyEFace.rtype)
+        elemPtr := type2.UnsafeGetIndex(objEFace.data, keyEFace.data)
+        if elemPtr == nil {
+                return nil, false
+        }
+        return packEFace(type2.pElemRType, elemPtr), true
+}
+
+func (type2 *UnsafeMapType) GetIndex(obj interface{}, key interface{}) interface{} {
+        objEFace := unpackEFace(obj)
+        assertType("MapType.GetIndex argument 1", type2.ptrRType, objEFace.rtype)
+        keyEFace := unpackEFace(key)
+        assertType("MapType.GetIndex argument 2", type2.pKeyRType, keyEFace.rtype)
+        elemPtr := type2.UnsafeGetIndex(objEFace.data, keyEFace.data)
+        return packEFace(type2.pElemRType, elemPtr)
+}
+
+func (type2 *UnsafeMapType) UnsafeGetIndex(obj unsafe.Pointer, key unsafe.Pointer) unsafe.Pointer {
+        return mapaccess(type2.rtype, *(*unsafe.Pointer)(obj), key)
+}
+
+func (type2 *UnsafeMapType) Iterate(obj interface{}) MapIterator {
+        objEFace := unpackEFace(obj)
+        assertType("MapType.Iterate argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeIterate(objEFace.data)
+}
+
+type UnsafeMapIterator struct {
+        *hiter
+        pKeyRType  unsafe.Pointer
+        pElemRType unsafe.Pointer
+}
+
+func (iter *UnsafeMapIterator) HasNext() bool {
+        return iter.key != nil
+}
+
+func (iter *UnsafeMapIterator) Next() (interface{}, interface{}) {
+        key, elem := iter.UnsafeNext()
+        return packEFace(iter.pKeyRType, key), packEFace(iter.pElemRType, elem)
+}
+
+func (iter *UnsafeMapIterator) UnsafeNext() (unsafe.Pointer, unsafe.Pointer) {
+        key := iter.key
+        elem := iter.value
+        mapiternext(iter.hiter)
+        return key, elem
+}
diff --git a/vendor/github.com/modern-go/reflect2/unsafe_ptr.go b/vendor/github.com/modern-go/reflect2/unsafe_ptr.go
new file mode 100644
index 0000000..8e5ec9c
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/unsafe_ptr.go
@@ -0,0 +1,46 @@
+package reflect2
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type UnsafePtrType struct {
+        unsafeType
+}
+
+func newUnsafePtrType(cfg *frozenConfig, type1 reflect.Type) *UnsafePtrType {
+        return &UnsafePtrType{
+                unsafeType: *newUnsafeType(cfg, type1),
+        }
+}
+
+func (type2 *UnsafePtrType) IsNil(obj interface{}) bool {
+        if obj == nil {
+                return true
+        }
+        objEFace := unpackEFace(obj)
+        assertType("Type.IsNil argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeIsNil(objEFace.data)
+}
+
+func (type2 *UnsafePtrType) UnsafeIsNil(ptr unsafe.Pointer) bool {
+        if ptr == nil {
+                return true
+        }
+        return *(*unsafe.Pointer)(ptr) == nil
+}
+
+func (type2 *UnsafePtrType) LikePtr() bool {
+        return true
+}
+
+func (type2 *UnsafePtrType) Indirect(obj interface{}) interface{} {
+        objEFace := unpackEFace(obj)
+        assertType("Type.Indirect argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeIndirect(objEFace.data)
+}
+
+func (type2 *UnsafePtrType) UnsafeIndirect(ptr unsafe.Pointer) interface{} {
+        return packEFace(type2.rtype, *(*unsafe.Pointer)(ptr))
+}
diff --git a/vendor/github.com/modern-go/reflect2/unsafe_slice.go b/vendor/github.com/modern-go/reflect2/unsafe_slice.go
new file mode 100644
index 0000000..1c6d876
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/unsafe_slice.go
@@ -0,0 +1,177 @@
+package reflect2
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+// sliceHeader is a safe version of SliceHeader used within this package.
+type sliceHeader struct {
+        Data unsafe.Pointer
+        Len  int
+        Cap  int
+}
+
+type UnsafeSliceType struct {
+        unsafeType
+        elemRType  unsafe.Pointer
+        pElemRType unsafe.Pointer
+        elemSize   uintptr
+}
+
+func newUnsafeSliceType(cfg *frozenConfig, type1 reflect.Type) SliceType {
+        elemType := type1.Elem()
+        return &UnsafeSliceType{
+                unsafeType: *newUnsafeType(cfg, type1),
+                pElemRType: unpackEFace(reflect.PtrTo(elemType)).data,
+                elemRType:  unpackEFace(elemType).data,
+                elemSize:   elemType.Size(),
+        }
+}
+
+func (type2 *UnsafeSliceType) Set(obj interface{}, val interface{}) {
+        objEFace := unpackEFace(obj)
+        assertType("Type.Set argument 1", type2.ptrRType, objEFace.rtype)
+        valEFace := unpackEFace(val)
+        assertType("Type.Set argument 2", type2.ptrRType, valEFace.rtype)
+        type2.UnsafeSet(objEFace.data, valEFace.data)
+}
+
+func (type2 *UnsafeSliceType) UnsafeSet(ptr unsafe.Pointer, val unsafe.Pointer) {
+        *(*sliceHeader)(ptr) = *(*sliceHeader)(val)
+}
+
+func (type2 *UnsafeSliceType) IsNil(obj interface{}) bool {
+        if obj == nil {
+                return true
+        }
+        objEFace := unpackEFace(obj)
+        assertType("Type.IsNil argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeIsNil(objEFace.data)
+}
+
+func (type2 *UnsafeSliceType) UnsafeIsNil(ptr unsafe.Pointer) bool {
+        if ptr == nil {
+                return true
+        }
+        return (*sliceHeader)(ptr).Data == nil
+}
+
+func (type2 *UnsafeSliceType) SetNil(obj interface{}) {
+        objEFace := unpackEFace(obj)
+        assertType("SliceType.SetNil argument 1", type2.ptrRType, objEFace.rtype)
+        type2.UnsafeSetNil(objEFace.data)
+}
+
+func (type2 *UnsafeSliceType) UnsafeSetNil(ptr unsafe.Pointer) {
+        header := (*sliceHeader)(ptr)
+        header.Len = 0
+        header.Cap = 0
+        header.Data = nil
+}
+
+func (type2 *UnsafeSliceType) MakeSlice(length int, cap int) interface{} {
+        return packEFace(type2.ptrRType, type2.UnsafeMakeSlice(length, cap))
+}
+
+func (type2 *UnsafeSliceType) UnsafeMakeSlice(length int, cap int) unsafe.Pointer {
+        header := &sliceHeader{unsafe_NewArray(type2.elemRType, cap), length, cap}
+        return unsafe.Pointer(header)
+}
+
+func (type2 *UnsafeSliceType) LengthOf(obj interface{}) int {
+        objEFace := unpackEFace(obj)
+        assertType("SliceType.Len argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeLengthOf(objEFace.data)
+}
+
+func (type2 *UnsafeSliceType) UnsafeLengthOf(obj unsafe.Pointer) int {
+        header := (*sliceHeader)(obj)
+        return header.Len
+}
+
+func (type2 *UnsafeSliceType) SetIndex(obj interface{}, index int, elem interface{}) {
+        objEFace := unpackEFace(obj)
+        assertType("SliceType.SetIndex argument 1", type2.ptrRType, objEFace.rtype)
+        elemEFace := unpackEFace(elem)
+        assertType("SliceType.SetIndex argument 3", type2.pElemRType, elemEFace.rtype)
+        type2.UnsafeSetIndex(objEFace.data, index, elemEFace.data)
+}
+
+func (type2 *UnsafeSliceType) UnsafeSetIndex(obj unsafe.Pointer, index int, elem unsafe.Pointer) {
+        header := (*sliceHeader)(obj)
+        elemPtr := arrayAt(header.Data, index, type2.elemSize, "i < s.Len")
+        typedmemmove(type2.elemRType, elemPtr, elem)
+}
+
+func (type2 *UnsafeSliceType) GetIndex(obj interface{}, index int) interface{} {
+        objEFace := unpackEFace(obj)
+        assertType("SliceType.GetIndex argument 1", type2.ptrRType, objEFace.rtype)
+        elemPtr := type2.UnsafeGetIndex(objEFace.data, index)
+        return packEFace(type2.pElemRType, elemPtr)
+}
+
+func (type2 *UnsafeSliceType) UnsafeGetIndex(obj unsafe.Pointer, index int) unsafe.Pointer {
+        header := (*sliceHeader)(obj)
+        return arrayAt(header.Data, index, type2.elemSize, "i < s.Len")
+}
+
+func (type2 *UnsafeSliceType) Append(obj interface{}, elem interface{}) {
+        objEFace := unpackEFace(obj)
+        assertType("SliceType.Append argument 1", type2.ptrRType, objEFace.rtype)
+        elemEFace := unpackEFace(elem)
+        assertType("SliceType.Append argument 2", type2.pElemRType, elemEFace.rtype)
+        type2.UnsafeAppend(objEFace.data, elemEFace.data)
+}
+
+func (type2 *UnsafeSliceType) UnsafeAppend(obj unsafe.Pointer, elem unsafe.Pointer) {
+        header := (*sliceHeader)(obj)
+        oldLen := header.Len
+        type2.UnsafeGrow(obj, oldLen+1)
+        type2.UnsafeSetIndex(obj, oldLen, elem)
+}
+
+func (type2 *UnsafeSliceType) Cap(obj interface{}) int {
+        objEFace := unpackEFace(obj)
+        assertType("SliceType.Cap argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeCap(objEFace.data)
+}
+
+func (type2 *UnsafeSliceType) UnsafeCap(ptr unsafe.Pointer) int {
+        return (*sliceHeader)(ptr).Cap
+}
+
+func (type2 *UnsafeSliceType) Grow(obj interface{}, newLength int) {
+        objEFace := unpackEFace(obj)
+        assertType("SliceType.Grow argument 1", type2.ptrRType, objEFace.rtype)
+        type2.UnsafeGrow(objEFace.data, newLength)
+}
+
+func (type2 *UnsafeSliceType) UnsafeGrow(obj unsafe.Pointer, newLength int) {
+        header := (*sliceHeader)(obj)
+        if newLength <= header.Cap {
+                header.Len = newLength
+                return
+        }
+        newCap := calcNewCap(header.Cap, newLength)
+        newHeader := (*sliceHeader)(type2.UnsafeMakeSlice(header.Len, newCap))
+        typedslicecopy(type2.elemRType, *newHeader, *header)
+        header.Data = newHeader.Data
+        header.Cap = newHeader.Cap
+        header.Len = newLength
+}
+
+func calcNewCap(cap int, expectedCap int) int {
+        if cap == 0 {
+                cap = expectedCap
+        } else {
+                for cap < expectedCap {
+                        if cap < 1024 {
+                                cap += cap
+                        } else {
+                                cap += cap / 4
+                        }
+                }
+        }
+        return cap
+}
diff --git a/vendor/github.com/modern-go/reflect2/unsafe_struct.go b/vendor/github.com/modern-go/reflect2/unsafe_struct.go
new file mode 100644
index 0000000..804d916
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/unsafe_struct.go
@@ -0,0 +1,59 @@
+package reflect2
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type UnsafeStructType struct {
+        unsafeType
+        likePtr bool
+}
+
+func newUnsafeStructType(cfg *frozenConfig, type1 reflect.Type) *UnsafeStructType {
+        return &UnsafeStructType{
+                unsafeType: *newUnsafeType(cfg, type1),
+                likePtr:    likePtrType(type1),
+        }
+}
+
+func (type2 *UnsafeStructType) LikePtr() bool {
+        return type2.likePtr
+}
+
+func (type2 *UnsafeStructType) Indirect(obj interface{}) interface{} {
+        objEFace := unpackEFace(obj)
+        assertType("Type.Indirect argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeIndirect(objEFace.data)
+}
+
+func (type2 *UnsafeStructType) UnsafeIndirect(ptr unsafe.Pointer) interface{} {
+        if type2.likePtr {
+                return packEFace(type2.rtype, *(*unsafe.Pointer)(ptr))
+        }
+        return packEFace(type2.rtype, ptr)
+}
+
+func (type2 *UnsafeStructType) FieldByName(name string) StructField {
+        structField, found := type2.Type.FieldByName(name)
+        if !found {
+                return nil
+        }
+        return newUnsafeStructField(type2, structField)
+}
+
+func (type2 *UnsafeStructType) Field(i int) StructField {
+        return newUnsafeStructField(type2, type2.Type.Field(i))
+}
+
+func (type2 *UnsafeStructType) FieldByIndex(index []int) StructField {
+        return newUnsafeStructField(type2, type2.Type.FieldByIndex(index))
+}
+
+func (type2 *UnsafeStructType) FieldByNameFunc(match func(string) bool) StructField {
+        structField, found := type2.Type.FieldByNameFunc(match)
+        if !found {
+                panic("field match condition not found in " + type2.Type.String())
+        }
+        return newUnsafeStructField(type2, structField)
+}
diff --git a/vendor/github.com/modern-go/reflect2/unsafe_type.go b/vendor/github.com/modern-go/reflect2/unsafe_type.go
new file mode 100644
index 0000000..1394171
--- /dev/null
+++ b/vendor/github.com/modern-go/reflect2/unsafe_type.go
@@ -0,0 +1,85 @@
+package reflect2
+
+import (
+        "reflect"
+        "unsafe"
+)
+
+type unsafeType struct {
+        safeType
+        rtype    unsafe.Pointer
+        ptrRType unsafe.Pointer
+}
+
+func newUnsafeType(cfg *frozenConfig, type1 reflect.Type) *unsafeType {
+        return &unsafeType{
+                safeType: safeType{
+                        Type: type1,
+                        cfg:  cfg,
+                },
+                rtype:    unpackEFace(type1).data,
+                ptrRType: unpackEFace(reflect.PtrTo(type1)).data,
+        }
+}
+
+func (type2 *unsafeType) Set(obj interface{}, val interface{}) {
+        objEFace := unpackEFace(obj)
+        assertType("Type.Set argument 1", type2.ptrRType, objEFace.rtype)
+        valEFace := unpackEFace(val)
+        assertType("Type.Set argument 2", type2.ptrRType, valEFace.rtype)
+        type2.UnsafeSet(objEFace.data, valEFace.data)
+}
+
+func (type2 *unsafeType) UnsafeSet(ptr unsafe.Pointer, val unsafe.Pointer) {
+        typedmemmove(type2.rtype, ptr, val)
+}
+
+func (type2 *unsafeType) IsNil(obj interface{}) bool {
+        objEFace := unpackEFace(obj)
+        assertType("Type.IsNil argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeIsNil(objEFace.data)
+}
+
+func (type2 *unsafeType) UnsafeIsNil(ptr unsafe.Pointer) bool {
+        return ptr == nil
+}
+
+func (type2 *unsafeType) UnsafeNew() unsafe.Pointer {
+        return unsafe_New(type2.rtype)
+}
+
+func (type2 *unsafeType) New() interface{} {
+        return packEFace(type2.ptrRType, type2.UnsafeNew())
+}
+
+func (type2 *unsafeType) PackEFace(ptr unsafe.Pointer) interface{} {
+        return packEFace(type2.ptrRType, ptr)
+}
+
+func (type2 *unsafeType) RType() uintptr {
+        return uintptr(type2.rtype)
+}
+
+func (type2 *unsafeType) Indirect(obj interface{}) interface{} {
+        objEFace := unpackEFace(obj)
+        assertType("Type.Indirect argument 1", type2.ptrRType, objEFace.rtype)
+        return type2.UnsafeIndirect(objEFace.data)
+}
+
+func (type2 *unsafeType) UnsafeIndirect(obj unsafe.Pointer) interface{} {
+        return packEFace(type2.rtype, obj)
+}
+
+func (type2 *unsafeType) LikePtr() bool {
+        return false
+}
+
+func assertType(where string, expectRType unsafe.Pointer, actualRType unsafe.Pointer) {
+        if expectRType != actualRType {
+                expectType := reflect.TypeOf(0)
+                (*iface)(unsafe.Pointer(&expectType)).data = expectRType
+                actualType := reflect.TypeOf(0)
+                (*iface)(unsafe.Pointer(&actualType)).data = actualRType
+                panic(where + ": expect " + expectType.String() + ", actual " + actualType.String())
+        }
+}
diff --git a/vendor/github.com/rs/xid/.appveyor.yml b/vendor/github.com/rs/xid/.appveyor.yml
new file mode 100644
index 0000000..c73bb33
--- /dev/null
+++ b/vendor/github.com/rs/xid/.appveyor.yml
@@ -0,0 +1,27 @@
+version: 1.0.0.{build}
+
+platform: x64
+
+branches:
+  only:
+    - master
+
+clone_folder: c:\gopath\src\github.com\rs\xid
+
+environment:
+  GOPATH: c:\gopath
+
+install:
+  - echo %PATH%
+  - echo %GOPATH%
+  - set PATH=%GOPATH%\bin;c:\go\bin;%PATH%
+  - go version
+  - go env
+  - go get -t .
+
+build_script:
+  - go build
+
+test_script:
+  - go test
+
diff --git a/vendor/github.com/rs/xid/.golangci.yml b/vendor/github.com/rs/xid/.golangci.yml
new file mode 100644
index 0000000..7929600
--- /dev/null
+++ b/vendor/github.com/rs/xid/.golangci.yml
@@ -0,0 +1,5 @@
+run:
+  tests: false
+
+output:
+  sort-results: true
diff --git a/vendor/github.com/rs/xid/.travis.yml b/vendor/github.com/rs/xid/.travis.yml
new file mode 100644
index 0000000..b37da15
--- /dev/null
+++ b/vendor/github.com/rs/xid/.travis.yml
@@ -0,0 +1,8 @@
+language: go
+go:
+- "1.9"
+- "1.10"
+- "master"
+matrix:
+  allow_failures:
+      - go: "master"
diff --git a/vendor/github.com/rs/xid/LICENSE b/vendor/github.com/rs/xid/LICENSE
new file mode 100644
index 0000000..47c5e9d
--- /dev/null
+++ b/vendor/github.com/rs/xid/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2015 Olivier Poitrey <[email protected]>
+
+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.
diff --git a/vendor/github.com/rs/xid/README.md b/vendor/github.com/rs/xid/README.md
new file mode 100644
index 0000000..974e67d
--- /dev/null
+++ b/vendor/github.com/rs/xid/README.md
@@ -0,0 +1,119 @@
+# Globally Unique ID Generator
+
+[![godoc](http://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://godoc.org/github.com/rs/xid) [![license](http://img.shields.io/badge/license-MIT-red.svg?style=flat)](https://raw.githubusercontent.com/rs/xid/master/LICENSE) [![Build Status](https://travis-ci.org/rs/xid.svg?branch=master)](https://travis-ci.org/rs/xid) [![Coverage](http://gocover.io/_badge/github.com/rs/xid)](http://gocover.io/github.com/rs/xid)
+
+Package xid is a globally unique id generator library, ready to safely be used directly in your server code.
+
+Xid uses the Mongo Object ID algorithm to generate globally unique ids with a different serialization (base64) to make it shorter when transported as a string:
+https://docs.mongodb.org/manual/reference/object-id/
+
+- 4-byte value representing the seconds since the Unix epoch,
+- 3-byte machine identifier,
+- 2-byte process id, and
+- 3-byte counter, starting with a random value.
+
+The binary representation of the id is compatible with Mongo 12 bytes Object IDs.
+The string representation is using base32 hex (w/o padding) for better space efficiency
+when stored in that form (20 bytes). The hex variant of base32 is used to retain the
+sortable property of the id.
+
+Xid doesn't use base64 because case sensitivity and the 2 non alphanum chars may be an
+issue when transported as a string between various systems. Base36 wasn't retained either
+because 1/ it's not standard 2/ the resulting size is not predictable (not bit aligned)
+and 3/ it would not remain sortable. To validate a base32 `xid`, expect a 20 chars long,
+all lowercase sequence of `a` to `v` letters and `0` to `9` numbers (`[0-9a-v]{20}`).
+
+UUIDs are 16 bytes (128 bits) and 36 chars as string representation. Twitter Snowflake
+ids are 8 bytes (64 bits) but require machine/data-center configuration and/or central
+generator servers. xid stands in between with 12 bytes (96 bits) and a more compact
+URL-safe string representation (20 chars). No configuration or central generator server
+is required so it can be used directly in server's code.
+
+| Name        | Binary Size | String Size    | Features
+|-------------|-------------|----------------|----------------
+| [UUID]      | 16 bytes    | 36 chars       | configuration free, not sortable
+| [shortuuid] | 16 bytes    | 22 chars       | configuration free, not sortable
+| [Snowflake] | 8 bytes     | up to 20 chars | needs machine/DC configuration, needs central server, sortable
+| [MongoID]   | 12 bytes    | 24 chars       | configuration free, sortable
+| xid         | 12 bytes    | 20 chars       | configuration free, sortable
+
+[UUID]: https://en.wikipedia.org/wiki/Universally_unique_identifier
+[shortuuid]: https://github.com/stochastic-technologies/shortuuid
+[Snowflake]: https://blog.twitter.com/2010/announcing-snowflake
+[MongoID]: https://docs.mongodb.org/manual/reference/object-id/
+
+Features:
+
+- Size: 12 bytes (96 bits), smaller than UUID, larger than snowflake
+- Base32 hex encoded by default (20 chars when transported as printable string, still sortable)
+- Non configured, you don't need set a unique machine and/or data center id
+- K-ordered
+- Embedded time with 1 second precision
+- Unicity guaranteed for 16,777,216 (24 bits) unique ids per second and per host/process
+- Lock-free (i.e.: unlike UUIDv1 and v2)
+
+Best used with [zerolog](https://github.com/rs/zerolog)'s
+[RequestIDHandler](https://godoc.org/github.com/rs/zerolog/hlog#RequestIDHandler).
+
+Notes:
+
+- Xid is dependent on the system time, a monotonic counter and so is not cryptographically secure. If unpredictability of IDs is important, you should not use Xids. It is worth noting that most other UUID-like implementations are also not cryptographically secure. You should use libraries that rely on cryptographically secure sources (like /dev/urandom on unix, crypto/rand in golang), if you want a truly random ID generator.
+
+References:
+
+- http://www.slideshare.net/davegardnerisme/unique-id-generation-in-distributed-systems
+- https://en.wikipedia.org/wiki/Universally_unique_identifier
+- https://blog.twitter.com/2010/announcing-snowflake
+- Python port by [Graham Abbott](https://github.com/graham): https://github.com/graham/python_xid
+- Scala port by [Egor Kolotaev](https://github.com/kolotaev): https://github.com/kolotaev/ride
+- Rust port by [Jérôme Renard](https://github.com/jeromer/): https://github.com/jeromer/libxid
+- Ruby port by [Valar](https://github.com/valarpirai/): https://github.com/valarpirai/ruby_xid
+- Java port by [0xShamil](https://github.com/0xShamil/): https://github.com/0xShamil/java-xid
+- Dart port by [Peter Bwire](https://github.com/pitabwire): https://pub.dev/packages/xid
+- PostgreSQL port by [Rasmus Holm](https://github.com/crholm): https://github.com/modfin/pg-xid
+- Swift port by [Uditha Atukorala](https://github.com/uditha-atukorala): https://github.com/uditha-atukorala/swift-xid
+- C++ port by [Uditha Atukorala](https://github.com/uditha-atukorala): https://github.com/uditha-atukorala/libxid
+
+## Install
+
+    go get github.com/rs/xid
+
+## Usage
+
+```go
+guid := xid.New()
+
+println(guid.String())
+// Output: 9m4e2mr0ui3e8a215n4g
+```
+
+Get `xid` embedded info:
+
+```go
+guid.Machine()
+guid.Pid()
+guid.Time()
+guid.Counter()
+```
+
+## Benchmark
+
+Benchmark against Go [Maxim Bublis](https://github.com/satori)'s [UUID](https://github.com/satori/go.uuid).
+
+```
+BenchmarkXID            20000000                91.1 ns/op            32 B/op          1 allocs/op
+BenchmarkXID-2          20000000                55.9 ns/op            32 B/op          1 allocs/op
+BenchmarkXID-4          50000000                32.3 ns/op            32 B/op          1 allocs/op
+BenchmarkUUIDv1         10000000               204 ns/op              48 B/op          1 allocs/op
+BenchmarkUUIDv1-2       10000000               160 ns/op              48 B/op          1 allocs/op
+BenchmarkUUIDv1-4       10000000               195 ns/op              48 B/op          1 allocs/op
+BenchmarkUUIDv4          1000000              1503 ns/op              64 B/op          2 allocs/op
+BenchmarkUUIDv4-2        1000000              1427 ns/op              64 B/op          2 allocs/op
+BenchmarkUUIDv4-4        1000000              1452 ns/op              64 B/op          2 allocs/op
+```
+
+Note: UUIDv1 requires a global lock, hence the performance degradation as we add more CPUs.
+
+## Licenses
+
+All source code is licensed under the [MIT License](https://raw.github.com/rs/xid/master/LICENSE).
diff --git a/vendor/github.com/rs/xid/error.go b/vendor/github.com/rs/xid/error.go
new file mode 100644
index 0000000..ea25374
--- /dev/null
+++ b/vendor/github.com/rs/xid/error.go
@@ -0,0 +1,11 @@
+package xid
+
+const (
+        // ErrInvalidID is returned when trying to unmarshal an invalid ID.
+        ErrInvalidID strErr = "xid: invalid ID"
+)
+
+// strErr allows declaring errors as constants.
+type strErr string
+
+func (err strErr) Error() string { return string(err) }
diff --git a/vendor/github.com/rs/xid/hostid_darwin.go b/vendor/github.com/rs/xid/hostid_darwin.go
new file mode 100644
index 0000000..08351ff
--- /dev/null
+++ b/vendor/github.com/rs/xid/hostid_darwin.go
@@ -0,0 +1,9 @@
+// +build darwin
+
+package xid
+
+import "syscall"
+
+func readPlatformMachineID() (string, error) {
+        return syscall.Sysctl("kern.uuid")
+}
diff --git a/vendor/github.com/rs/xid/hostid_fallback.go b/vendor/github.com/rs/xid/hostid_fallback.go
new file mode 100644
index 0000000..7fbd3c0
--- /dev/null
+++ b/vendor/github.com/rs/xid/hostid_fallback.go
@@ -0,0 +1,9 @@
+// +build !darwin,!linux,!freebsd,!windows
+
+package xid
+
+import "errors"
+
+func readPlatformMachineID() (string, error) {
+        return "", errors.New("not implemented")
+}
diff --git a/vendor/github.com/rs/xid/hostid_freebsd.go b/vendor/github.com/rs/xid/hostid_freebsd.go
new file mode 100644
index 0000000..be25a03
--- /dev/null
+++ b/vendor/github.com/rs/xid/hostid_freebsd.go
@@ -0,0 +1,9 @@
+// +build freebsd
+
+package xid
+
+import "syscall"
+
+func readPlatformMachineID() (string, error) {
+        return syscall.Sysctl("kern.hostuuid")
+}
diff --git a/vendor/github.com/rs/xid/hostid_linux.go b/vendor/github.com/rs/xid/hostid_linux.go
new file mode 100644
index 0000000..837b204
--- /dev/null
+++ b/vendor/github.com/rs/xid/hostid_linux.go
@@ -0,0 +1,13 @@
+// +build linux
+
+package xid
+
+import "io/ioutil"
+
+func readPlatformMachineID() (string, error) {
+        b, err := ioutil.ReadFile("/etc/machine-id")
+        if err != nil || len(b) == 0 {
+                b, err = ioutil.ReadFile("/sys/class/dmi/id/product_uuid")
+        }
+        return string(b), err
+}
diff --git a/vendor/github.com/rs/xid/hostid_windows.go b/vendor/github.com/rs/xid/hostid_windows.go
new file mode 100644
index 0000000..ec2593e
--- /dev/null
+++ b/vendor/github.com/rs/xid/hostid_windows.go
@@ -0,0 +1,38 @@
+// +build windows
+
+package xid
+
+import (
+        "fmt"
+        "syscall"
+        "unsafe"
+)
+
+func readPlatformMachineID() (string, error) {
+        // source: https://github.com/shirou/gopsutil/blob/master/host/host_syscall.go
+        var h syscall.Handle
+        err := syscall.RegOpenKeyEx(syscall.HKEY_LOCAL_MACHINE, syscall.StringToUTF16Ptr(`SOFTWARE\Microsoft\Cryptography`), 0, syscall.KEY_READ|syscall.KEY_WOW64_64KEY, &h)
+        if err != nil {
+                return "", err
+        }
+        defer syscall.RegCloseKey(h)
+
+        const syscallRegBufLen = 74 // len(`{`) + len(`abcdefgh-1234-456789012-123345456671` * 2) + len(`}`) // 2 == bytes/UTF16
+        const uuidLen = 36
+
+        var regBuf [syscallRegBufLen]uint16
+        bufLen := uint32(syscallRegBufLen)
+        var valType uint32
+        err = syscall.RegQueryValueEx(h, syscall.StringToUTF16Ptr(`MachineGuid`), nil, &valType, (*byte)(unsafe.Pointer(&regBuf[0])), &bufLen)
+        if err != nil {
+                return "", err
+        }
+
+        hostID := syscall.UTF16ToString(regBuf[:])
+        hostIDLen := len(hostID)
+        if hostIDLen != uuidLen {
+                return "", fmt.Errorf("HostID incorrect: %q\n", hostID)
+        }
+
+        return hostID, nil
+}
diff --git a/vendor/github.com/rs/xid/id.go b/vendor/github.com/rs/xid/id.go
new file mode 100644
index 0000000..fcd7a04
--- /dev/null
+++ b/vendor/github.com/rs/xid/id.go
@@ -0,0 +1,391 @@
+// Package xid is a globally unique id generator suited for web scale
+//
+// Xid is using Mongo Object ID algorithm to generate globally unique ids:
+// https://docs.mongodb.org/manual/reference/object-id/
+//
+//   - 4-byte value representing the seconds since the Unix epoch,
+//   - 3-byte machine identifier,
+//   - 2-byte process id, and
+//   - 3-byte counter, starting with a random value.
+//
+// The binary representation of the id is compatible with Mongo 12 bytes Object IDs.
+// The string representation is using base32 hex (w/o padding) for better space efficiency
+// when stored in that form (20 bytes). The hex variant of base32 is used to retain the
+// sortable property of the id.
+//
+// Xid doesn't use base64 because case sensitivity and the 2 non alphanum chars may be an
+// issue when transported as a string between various systems. Base36 wasn't retained either
+// because 1/ it's not standard 2/ the resulting size is not predictable (not bit aligned)
+// and 3/ it would not remain sortable. To validate a base32 `xid`, expect a 20 chars long,
+// all lowercase sequence of `a` to `v` letters and `0` to `9` numbers (`[0-9a-v]{20}`).
+//
+// UUID is 16 bytes (128 bits), snowflake is 8 bytes (64 bits), xid stands in between
+// with 12 bytes with a more compact string representation ready for the web and no
+// required configuration or central generation server.
+//
+// Features:
+//
+//   - Size: 12 bytes (96 bits), smaller than UUID, larger than snowflake
+//   - Base32 hex encoded by default (16 bytes storage when transported as printable string)
+//   - Non configured, you don't need set a unique machine and/or data center id
+//   - K-ordered
+//   - Embedded time with 1 second precision
+//   - Unicity guaranteed for 16,777,216 (24 bits) unique ids per second and per host/process
+//
+// Best used with xlog's RequestIDHandler (https://godoc.org/github.com/rs/xlog#RequestIDHandler).
+//
+// References:
+//
+//   - http://www.slideshare.net/davegardnerisme/unique-id-generation-in-distributed-systems
+//   - https://en.wikipedia.org/wiki/Universally_unique_identifier
+//   - https://blog.twitter.com/2010/announcing-snowflake
+package xid
+
+import (
+        "bytes"
+        "crypto/sha256"
+        "crypto/rand"
+        "database/sql/driver"
+        "encoding/binary"
+        "fmt"
+        "hash/crc32"
+        "io/ioutil"
+        "os"
+        "sort"
+        "sync/atomic"
+        "time"
+        "unsafe"
+)
+
+// Code inspired from mgo/bson ObjectId
+
+// ID represents a unique request id
+type ID [rawLen]byte
+
+const (
+        encodedLen = 20 // string encoded len
+        rawLen     = 12 // binary raw len
+
+        // encoding stores a custom version of the base32 encoding with lower case
+        // letters.
+        encoding = "0123456789abcdefghijklmnopqrstuv"
+)
+
+var (
+        // objectIDCounter is atomically incremented when generating a new ObjectId. It's
+        // used as the counter part of an id. This id is initialized with a random value.
+        objectIDCounter = randInt()
+
+        // machineID is generated once and used in subsequent calls to the New* functions.
+        machineID = readMachineID()
+
+        // pid stores the current process id
+        pid = os.Getpid()
+
+        nilID ID
+
+        // dec is the decoding map for base32 encoding
+        dec [256]byte
+)
+
+func init() {
+        for i := 0; i < len(dec); i++ {
+                dec[i] = 0xFF
+        }
+        for i := 0; i < len(encoding); i++ {
+                dec[encoding[i]] = byte(i)
+        }
+
+        // If /proc/self/cpuset exists and is not /, we can assume that we are in a
+        // form of container and use the content of cpuset xor-ed with the PID in
+        // order get a reasonable machine global unique PID.
+        b, err := ioutil.ReadFile("/proc/self/cpuset")
+        if err == nil && len(b) > 1 {
+                pid ^= int(crc32.ChecksumIEEE(b))
+        }
+}
+
+// readMachineID generates a machine ID, derived from a platform-specific machine ID
+// value, or else the machine's hostname, or else a randomly-generated number.
+// It panics if all of these methods fail.
+func readMachineID() []byte {
+        id := make([]byte, 3)
+        hid, err := readPlatformMachineID()
+        if err != nil || len(hid) == 0 {
+                hid, err = os.Hostname()
+        }
+        if err == nil && len(hid) != 0 {
+                hw := sha256.New()
+                hw.Write([]byte(hid))
+                copy(id, hw.Sum(nil))
+        } else {
+                // Fallback to rand number if machine id can't be gathered
+                if _, randErr := rand.Reader.Read(id); randErr != nil {
+                        panic(fmt.Errorf("xid: cannot get hostname nor generate a random number: %v; %v", err, randErr))
+                }
+        }
+        return id
+}
+
+// randInt generates a random uint32
+func randInt() uint32 {
+        b := make([]byte, 3)
+        if _, err := rand.Reader.Read(b); err != nil {
+                panic(fmt.Errorf("xid: cannot generate random number: %v;", err))
+        }
+        return uint32(b[0])<<16 | uint32(b[1])<<8 | uint32(b[2])
+}
+
+// New generates a globally unique ID
+func New() ID {
+        return NewWithTime(time.Now())
+}
+
+// NewWithTime generates a globally unique ID with the passed in time
+func NewWithTime(t time.Time) ID {
+        var id ID
+        // Timestamp, 4 bytes, big endian
+        binary.BigEndian.PutUint32(id[:], uint32(t.Unix()))
+        // Machine ID, 3 bytes
+        id[4] = machineID[0]
+        id[5] = machineID[1]
+        id[6] = machineID[2]
+        // Pid, 2 bytes, specs don't specify endianness, but we use big endian.
+        id[7] = byte(pid >> 8)
+        id[8] = byte(pid)
+        // Increment, 3 bytes, big endian
+        i := atomic.AddUint32(&objectIDCounter, 1)
+        id[9] = byte(i >> 16)
+        id[10] = byte(i >> 8)
+        id[11] = byte(i)
+        return id
+}
+
+// FromString reads an ID from its string representation
+func FromString(id string) (ID, error) {
+        i := &ID{}
+        err := i.UnmarshalText([]byte(id))
+        return *i, err
+}
+
+// String returns a base32 hex lowercased with no padding representation of the id (char set is 0-9, a-v).
+func (id ID) String() string {
+        text := make([]byte, encodedLen)
+        encode(text, id[:])
+        return *(*string)(unsafe.Pointer(&text))
+}
+
+// Encode encodes the id using base32 encoding, writing 20 bytes to dst and return it.
+func (id ID) Encode(dst []byte) []byte {
+        encode(dst, id[:])
+        return dst
+}
+
+// MarshalText implements encoding/text TextMarshaler interface
+func (id ID) MarshalText() ([]byte, error) {
+        text := make([]byte, encodedLen)
+        encode(text, id[:])
+        return text, nil
+}
+
+// MarshalJSON implements encoding/json Marshaler interface
+func (id ID) MarshalJSON() ([]byte, error) {
+        if id.IsNil() {
+                return []byte("null"), nil
+        }
+        text := make([]byte, encodedLen+2)
+        encode(text[1:encodedLen+1], id[:])
+        text[0], text[encodedLen+1] = '"', '"'
+        return text, nil
+}
+
+// encode by unrolling the stdlib base32 algorithm + removing all safe checks
+func encode(dst, id []byte) {
+        _ = dst[19]
+        _ = id[11]
+
+        dst[19] = encoding[(id[11]<<4)&0x1F]
+        dst[18] = encoding[(id[11]>>1)&0x1F]
+        dst[17] = encoding[(id[11]>>6)&0x1F|(id[10]<<2)&0x1F]
+        dst[16] = encoding[id[10]>>3]
+        dst[15] = encoding[id[9]&0x1F]
+        dst[14] = encoding[(id[9]>>5)|(id[8]<<3)&0x1F]
+        dst[13] = encoding[(id[8]>>2)&0x1F]
+        dst[12] = encoding[id[8]>>7|(id[7]<<1)&0x1F]
+        dst[11] = encoding[(id[7]>>4)&0x1F|(id[6]<<4)&0x1F]
+        dst[10] = encoding[(id[6]>>1)&0x1F]
+        dst[9] = encoding[(id[6]>>6)&0x1F|(id[5]<<2)&0x1F]
+        dst[8] = encoding[id[5]>>3]
+        dst[7] = encoding[id[4]&0x1F]
+        dst[6] = encoding[id[4]>>5|(id[3]<<3)&0x1F]
+        dst[5] = encoding[(id[3]>>2)&0x1F]
+        dst[4] = encoding[id[3]>>7|(id[2]<<1)&0x1F]
+        dst[3] = encoding[(id[2]>>4)&0x1F|(id[1]<<4)&0x1F]
+        dst[2] = encoding[(id[1]>>1)&0x1F]
+        dst[1] = encoding[(id[1]>>6)&0x1F|(id[0]<<2)&0x1F]
+        dst[0] = encoding[id[0]>>3]
+}
+
+// UnmarshalText implements encoding/text TextUnmarshaler interface
+func (id *ID) UnmarshalText(text []byte) error {
+        if len(text) != encodedLen {
+                return ErrInvalidID
+        }
+        for _, c := range text {
+                if dec[c] == 0xFF {
+                        return ErrInvalidID
+                }
+        }
+        if !decode(id, text) {
+                *id = nilID
+                return ErrInvalidID
+        }
+        return nil
+}
+
+// UnmarshalJSON implements encoding/json Unmarshaler interface
+func (id *ID) UnmarshalJSON(b []byte) error {
+        s := string(b)
+        if s == "null" {
+                *id = nilID
+                return nil
+        }
+        // Check the slice length to prevent panic on passing it to UnmarshalText()
+        if len(b) < 2 {
+                return ErrInvalidID
+        }
+        return id.UnmarshalText(b[1 : len(b)-1])
+}
+
+// decode by unrolling the stdlib base32 algorithm + customized safe check.
+func decode(id *ID, src []byte) bool {
+        _ = src[19]
+        _ = id[11]
+
+        id[11] = dec[src[17]]<<6 | dec[src[18]]<<1 | dec[src[19]]>>4
+        // check the last byte
+        if encoding[(id[11]<<4)&0x1F] != src[19] {
+                return false
+        }
+        id[10] = dec[src[16]]<<3 | dec[src[17]]>>2
+        id[9] = dec[src[14]]<<5 | dec[src[15]]
+        id[8] = dec[src[12]]<<7 | dec[src[13]]<<2 | dec[src[14]]>>3
+        id[7] = dec[src[11]]<<4 | dec[src[12]]>>1
+        id[6] = dec[src[9]]<<6 | dec[src[10]]<<1 | dec[src[11]]>>4
+        id[5] = dec[src[8]]<<3 | dec[src[9]]>>2
+        id[4] = dec[src[6]]<<5 | dec[src[7]]
+        id[3] = dec[src[4]]<<7 | dec[src[5]]<<2 | dec[src[6]]>>3
+        id[2] = dec[src[3]]<<4 | dec[src[4]]>>1
+        id[1] = dec[src[1]]<<6 | dec[src[2]]<<1 | dec[src[3]]>>4
+        id[0] = dec[src[0]]<<3 | dec[src[1]]>>2
+        return true
+}
+
+// Time returns the timestamp part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ID) Time() time.Time {
+        // First 4 bytes of ObjectId is 32-bit big-endian seconds from epoch.
+        secs := int64(binary.BigEndian.Uint32(id[0:4]))
+        return time.Unix(secs, 0)
+}
+
+// Machine returns the 3-byte machine id part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ID) Machine() []byte {
+        return id[4:7]
+}
+
+// Pid returns the process id part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ID) Pid() uint16 {
+        return binary.BigEndian.Uint16(id[7:9])
+}
+
+// Counter returns the incrementing value part of the id.
+// It's a runtime error to call this method with an invalid id.
+func (id ID) Counter() int32 {
+        b := id[9:12]
+        // Counter is stored as big-endian 3-byte value
+        return int32(uint32(b[0])<<16 | uint32(b[1])<<8 | uint32(b[2]))
+}
+
+// Value implements the driver.Valuer interface.
+func (id ID) Value() (driver.Value, error) {
+        if id.IsNil() {
+                return nil, nil
+        }
+        b, err := id.MarshalText()
+        return string(b), err
+}
+
+// Scan implements the sql.Scanner interface.
+func (id *ID) Scan(value interface{}) (err error) {
+        switch val := value.(type) {
+        case string:
+                return id.UnmarshalText([]byte(val))
+        case []byte:
+                return id.UnmarshalText(val)
+        case nil:
+                *id = nilID
+                return nil
+        default:
+                return fmt.Errorf("xid: scanning unsupported type: %T", value)
+        }
+}
+
+// IsNil Returns true if this is a "nil" ID
+func (id ID) IsNil() bool {
+        return id == nilID
+}
+
+// Alias of IsNil
+func (id ID) IsZero() bool {
+        return id.IsNil()
+}
+
+// NilID returns a zero value for `xid.ID`.
+func NilID() ID {
+        return nilID
+}
+
+// Bytes returns the byte array representation of `ID`
+func (id ID) Bytes() []byte {
+        return id[:]
+}
+
+// FromBytes convert the byte array representation of `ID` back to `ID`
+func FromBytes(b []byte) (ID, error) {
+        var id ID
+        if len(b) != rawLen {
+                return id, ErrInvalidID
+        }
+        copy(id[:], b)
+        return id, nil
+}
+
+// Compare returns an integer comparing two IDs. It behaves just like `bytes.Compare`.
+// The result will be 0 if two IDs are identical, -1 if current id is less than the other one,
+// and 1 if current id is greater than the other.
+func (id ID) Compare(other ID) int {
+        return bytes.Compare(id[:], other[:])
+}
+
+type sorter []ID
+
+func (s sorter) Len() int {
+        return len(s)
+}
+
+func (s sorter) Less(i, j int) bool {
+        return s[i].Compare(s[j]) < 0
+}
+
+func (s sorter) Swap(i, j int) {
+        s[i], s[j] = s[j], s[i]
+}
+
+// Sort sorts an array of IDs inplace.
+// It works by wrapping `[]ID` and use `sort.Sort`.
+func Sort(ids []ID) {
+        sort.Sort(sorter(ids))
+}
diff --git a/vendor/github.com/sirupsen/logrus/.gitignore b/vendor/github.com/sirupsen/logrus/.gitignore
new file mode 100644
index 0000000..1fb13ab
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/.gitignore
@@ -0,0 +1,4 @@
+logrus
+vendor
+
+.idea/
diff --git a/vendor/github.com/sirupsen/logrus/.golangci.yml b/vendor/github.com/sirupsen/logrus/.golangci.yml
new file mode 100644
index 0000000..65dc285
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/.golangci.yml
@@ -0,0 +1,40 @@
+run:
+  # do not run on test files yet
+  tests: false
+
+# all available settings of specific linters
+linters-settings:
+  errcheck:
+    # report about not checking of errors in type assetions: `a := b.(MyStruct)`;
+    # default is false: such cases aren't reported by default.
+    check-type-assertions: false
+
+    # report about assignment of errors to blank identifier: `num, _ := strconv.Atoi(numStr)`;
+    # default is false: such cases aren't reported by default.
+    check-blank: false
+
+  lll:
+    line-length: 100
+    tab-width: 4
+
+  prealloc:
+    simple: false
+    range-loops: false
+    for-loops: false
+
+  whitespace:
+    multi-if: false   # Enforces newlines (or comments) after every multi-line if statement
+    multi-func: false # Enforces newlines (or comments) after every multi-line function signature
+
+linters:
+  enable:
+    - megacheck
+    - govet
+  disable:
+    - maligned
+    - prealloc
+  disable-all: false
+  presets:
+    - bugs
+    - unused
+  fast: false
diff --git a/vendor/github.com/sirupsen/logrus/.travis.yml b/vendor/github.com/sirupsen/logrus/.travis.yml
new file mode 100644
index 0000000..c1dbd5a
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/.travis.yml
@@ -0,0 +1,15 @@
+language: go
+go_import_path: github.com/sirupsen/logrus
+git:
+  depth: 1
+env:
+  - GO111MODULE=on
+go: 1.15.x
+os: linux
+install:
+  - ./travis/install.sh
+script:
+  - cd ci
+  - go run mage.go -v -w ../ crossBuild
+  - go run mage.go -v -w ../ lint
+  - go run mage.go -v -w ../ test
diff --git a/vendor/github.com/sirupsen/logrus/CHANGELOG.md b/vendor/github.com/sirupsen/logrus/CHANGELOG.md
new file mode 100644
index 0000000..7567f61
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/CHANGELOG.md
@@ -0,0 +1,259 @@
+# 1.8.1
+Code quality:
+  * move magefile in its own subdir/submodule to remove magefile dependency on logrus consumer
+  * improve timestamp format documentation
+
+Fixes:
+  * fix race condition on logger hooks
+
+
+# 1.8.0
+
+Correct versioning number replacing v1.7.1.
+
+# 1.7.1
+
+Beware this release has introduced a new public API and its semver is therefore incorrect.
+
+Code quality:
+  * use go 1.15 in travis
+  * use magefile as task runner
+
+Fixes:
+  * small fixes about new go 1.13 error formatting system
+  * Fix for long time race condiction with mutating data hooks
+
+Features:
+  * build support for zos
+
+# 1.7.0
+Fixes:
+  * the dependency toward a windows terminal library has been removed
+
+Features:
+  * a new buffer pool management API has been added
+  * a set of `<LogLevel>Fn()` functions have been added
+
+# 1.6.0
+Fixes:
+  * end of line cleanup
+  * revert the entry concurrency bug fix whic leads to deadlock under some circumstances
+  * update dependency on go-windows-terminal-sequences to fix a crash with go 1.14
+
+Features:
+  * add an option to the `TextFormatter` to completely disable fields quoting
+
+# 1.5.0
+Code quality:
+  * add golangci linter run on travis
+
+Fixes:
+  * add mutex for hooks concurrent access on `Entry` data
+  * caller function field for go1.14
+  * fix build issue for gopherjs target
+
+Feature:
+  * add an hooks/writer sub-package whose goal is to split output on different stream depending on the trace level
+  * add a `DisableHTMLEscape` option in the `JSONFormatter`
+  * add `ForceQuote` and `PadLevelText` options in the `TextFormatter`
+
+# 1.4.2
+  * Fixes build break for plan9, nacl, solaris
+# 1.4.1
+This new release introduces:
+  * Enhance TextFormatter to not print caller information when they are empty (#944)
+  * Remove dependency on golang.org/x/crypto (#932, #943)
+
+Fixes:
+  * Fix Entry.WithContext method to return a copy of the initial entry (#941)
+
+# 1.4.0
+This new release introduces:
+  * Add `DeferExitHandler`, similar to `RegisterExitHandler` but prepending the handler to the list of handlers (semantically like `defer`) (#848).
+  * Add `CallerPrettyfier` to `JSONFormatter` and `TextFormatter` (#909, #911)
+  * Add `Entry.WithContext()` and `Entry.Context`, to set a context on entries to be used e.g. in hooks (#919).
+
+Fixes:
+  * Fix wrong method calls `Logger.Print` and `Logger.Warningln` (#893).
+  * Update `Entry.Logf` to not do string formatting unless the log level is enabled (#903)
+  * Fix infinite recursion on unknown `Level.String()` (#907)
+  * Fix race condition in `getCaller` (#916).
+
+
+# 1.3.0
+This new release introduces:
+  * Log, Logf, Logln functions for Logger and Entry that take a Level
+
+Fixes:
+  * Building prometheus node_exporter on AIX (#840)
+  * Race condition in TextFormatter (#468)
+  * Travis CI import path (#868)
+  * Remove coloured output on Windows (#862)
+  * Pointer to func as field in JSONFormatter (#870)
+  * Properly marshal Levels (#873)
+
+# 1.2.0
+This new release introduces:
+  * A new method `SetReportCaller` in the `Logger` to enable the file, line and calling function from which the trace has been issued
+  * A new trace level named `Trace` whose level is below `Debug`
+  * A configurable exit function to be called upon a Fatal trace
+  * The `Level` object now implements `encoding.TextUnmarshaler` interface
+
+# 1.1.1
+This is a bug fix release.
+  * fix the build break on Solaris
+  * don't drop a whole trace in JSONFormatter when a field param is a function pointer which can not be serialized
+
+# 1.1.0
+This new release introduces:
+  * several fixes:
+    * a fix for a race condition on entry formatting
+    * proper cleanup of previously used entries before putting them back in the pool
+    * the extra new line at the end of message in text formatter has been removed
+  * a new global public API to check if a level is activated: IsLevelEnabled
+  * the following methods have been added to the Logger object
+    * IsLevelEnabled
+    * SetFormatter
+    * SetOutput
+    * ReplaceHooks
+  * introduction of go module
+  * an indent configuration for the json formatter
+  * output colour support for windows
+  * the field sort function is now configurable for text formatter
+  * the CLICOLOR and CLICOLOR\_FORCE environment variable support in text formater
+
+# 1.0.6
+
+This new release introduces:
+  * a new api WithTime which allows to easily force the time of the log entry
+    which is mostly useful for logger wrapper
+  * a fix reverting the immutability of the entry given as parameter to the hooks
+    a new configuration field of the json formatter in order to put all the fields
+    in a nested dictionnary
+  * a new SetOutput method in the Logger
+  * a new configuration of the textformatter to configure the name of the default keys
+  * a new configuration of the text formatter to disable the level truncation
+
+# 1.0.5
+
+* Fix hooks race (#707)
+* Fix panic deadlock (#695)
+
+# 1.0.4
+
+* Fix race when adding hooks (#612)
+* Fix terminal check in AppEngine (#635)
+
+# 1.0.3
+
+* Replace example files with testable examples
+
+# 1.0.2
+
+* bug: quote non-string values in text formatter (#583)
+* Make (*Logger) SetLevel a public method
+
+# 1.0.1
+
+* bug: fix escaping in text formatter (#575)
+
+# 1.0.0
+
+* Officially changed name to lower-case
+* bug: colors on Windows 10 (#541)
+* bug: fix race in accessing level (#512)
+
+# 0.11.5
+
+* feature: add writer and writerlevel to entry (#372)
+
+# 0.11.4
+
+* bug: fix undefined variable on solaris (#493)
+
+# 0.11.3
+
+* formatter: configure quoting of empty values (#484)
+* formatter: configure quoting character (default is `"`) (#484)
+* bug: fix not importing io correctly in non-linux environments (#481)
+
+# 0.11.2
+
+* bug: fix windows terminal detection (#476)
+
+# 0.11.1
+
+* bug: fix tty detection with custom out (#471)
+
+# 0.11.0
+
+* performance: Use bufferpool to allocate (#370)
+* terminal: terminal detection for app-engine (#343)
+* feature: exit handler (#375)
+
+# 0.10.0
+
+* feature: Add a test hook (#180)
+* feature: `ParseLevel` is now case-insensitive (#326)
+* feature: `FieldLogger` interface that generalizes `Logger` and `Entry` (#308)
+* performance: avoid re-allocations on `WithFields` (#335)
+
+# 0.9.0
+
+* logrus/text_formatter: don't emit empty msg
+* logrus/hooks/airbrake: move out of main repository
+* logrus/hooks/sentry: move out of main repository
+* logrus/hooks/papertrail: move out of main repository
+* logrus/hooks/bugsnag: move out of main repository
+* logrus/core: run tests with `-race`
+* logrus/core: detect TTY based on `stderr`
+* logrus/core: support `WithError` on logger
+* logrus/core: Solaris support
+
+# 0.8.7
+
+* logrus/core: fix possible race (#216)
+* logrus/doc: small typo fixes and doc improvements
+
+
+# 0.8.6
+
+* hooks/raven: allow passing an initialized client
+
+# 0.8.5
+
+* logrus/core: revert #208
+
+# 0.8.4
+
+* formatter/text: fix data race (#218)
+
+# 0.8.3
+
+* logrus/core: fix entry log level (#208)
+* logrus/core: improve performance of text formatter by 40%
+* logrus/core: expose `LevelHooks` type
+* logrus/core: add support for DragonflyBSD and NetBSD
+* formatter/text: print structs more verbosely
+
+# 0.8.2
+
+* logrus: fix more Fatal family functions
+
+# 0.8.1
+
+* logrus: fix not exiting on `Fatalf` and `Fatalln`
+
+# 0.8.0
+
+* logrus: defaults to stderr instead of stdout
+* hooks/sentry: add special field for `*http.Request`
+* formatter/text: ignore Windows for colors
+
+# 0.7.3
+
+* formatter/\*: allow configuration of timestamp layout
+
+# 0.7.2
+
+* formatter/text: Add configuration option for time format (#158)
diff --git a/vendor/github.com/sirupsen/logrus/LICENSE b/vendor/github.com/sirupsen/logrus/LICENSE
new file mode 100644
index 0000000..f090cb4
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Simon Eskildsen
+
+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.
diff --git a/vendor/github.com/sirupsen/logrus/README.md b/vendor/github.com/sirupsen/logrus/README.md
new file mode 100644
index 0000000..d1d4a85
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/README.md
@@ -0,0 +1,515 @@
+# Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/> [![Build Status](https://github.com/sirupsen/logrus/workflows/CI/badge.svg)](https://github.com/sirupsen/logrus/actions?query=workflow%3ACI) [![Build Status](https://travis-ci.org/sirupsen/logrus.svg?branch=master)](https://travis-ci.org/sirupsen/logrus) [![Go Reference](https://pkg.go.dev/badge/github.com/sirupsen/logrus.svg)](https://pkg.go.dev/github.com/sirupsen/logrus)
+
+Logrus is a structured logger for Go (golang), completely API compatible with
+the standard library logger.
+
+**Logrus is in maintenance-mode.** We will not be introducing new features. It's
+simply too hard to do in a way that won't break many people's projects, which is
+the last thing you want from your Logging library (again...).
+
+This does not mean Logrus is dead. Logrus will continue to be maintained for
+security, (backwards compatible) bug fixes, and performance (where we are
+limited by the interface).
+
+I believe Logrus' biggest contribution is to have played a part in today's
+widespread use of structured logging in Golang. There doesn't seem to be a
+reason to do a major, breaking iteration into Logrus V2, since the fantastic Go
+community has built those independently. Many fantastic alternatives have sprung
+up. Logrus would look like those, had it been re-designed with what we know
+about structured logging in Go today. Check out, for example,
+[Zerolog][zerolog], [Zap][zap], and [Apex][apex].
+
+[zerolog]: https://github.com/rs/zerolog
+[zap]: https://github.com/uber-go/zap
+[apex]: https://github.com/apex/log
+
+**Seeing weird case-sensitive problems?** It's in the past been possible to
+import Logrus as both upper- and lower-case. Due to the Go package environment,
+this caused issues in the community and we needed a standard. Some environments
+experienced problems with the upper-case variant, so the lower-case was decided.
+Everything using `logrus` will need to use the lower-case:
+`github.com/sirupsen/logrus`. Any package that isn't, should be changed.
+
+To fix Glide, see [these
+comments](https://github.com/sirupsen/logrus/issues/553#issuecomment-306591437).
+For an in-depth explanation of the casing issue, see [this
+comment](https://github.com/sirupsen/logrus/issues/570#issuecomment-313933276).
+
+Nicely color-coded in development (when a TTY is attached, otherwise just
+plain text):
+
+![Colored](http://i.imgur.com/PY7qMwd.png)
+
+With `log.SetFormatter(&log.JSONFormatter{})`, for easy parsing by logstash
+or Splunk:
+
+```text
+{"animal":"walrus","level":"info","msg":"A group of walrus emerges from the
+ocean","size":10,"time":"2014-03-10 19:57:38.562264131 -0400 EDT"}
+
+{"level":"warning","msg":"The group's number increased tremendously!",
+"number":122,"omg":true,"time":"2014-03-10 19:57:38.562471297 -0400 EDT"}
+
+{"animal":"walrus","level":"info","msg":"A giant walrus appears!",
+"size":10,"time":"2014-03-10 19:57:38.562500591 -0400 EDT"}
+
+{"animal":"walrus","level":"info","msg":"Tremendously sized cow enters the ocean.",
+"size":9,"time":"2014-03-10 19:57:38.562527896 -0400 EDT"}
+
+{"level":"fatal","msg":"The ice breaks!","number":100,"omg":true,
+"time":"2014-03-10 19:57:38.562543128 -0400 EDT"}
+```
+
+With the default `log.SetFormatter(&log.TextFormatter{})` when a TTY is not
+attached, the output is compatible with the
+[logfmt](http://godoc.org/github.com/kr/logfmt) format:
+
+```text
+time="2015-03-26T01:27:38-04:00" level=debug msg="Started observing beach" animal=walrus number=8
+time="2015-03-26T01:27:38-04:00" level=info msg="A group of walrus emerges from the ocean" animal=walrus size=10
+time="2015-03-26T01:27:38-04:00" level=warning msg="The group's number increased tremendously!" number=122 omg=true
+time="2015-03-26T01:27:38-04:00" level=debug msg="Temperature changes" temperature=-4
+time="2015-03-26T01:27:38-04:00" level=panic msg="It's over 9000!" animal=orca size=9009
+time="2015-03-26T01:27:38-04:00" level=fatal msg="The ice breaks!" err=&{0x2082280c0 map[animal:orca size:9009] 2015-03-26 01:27:38.441574009 -0400 EDT panic It's over 9000!} number=100 omg=true
+```
+To ensure this behaviour even if a TTY is attached, set your formatter as follows:
+
+```go
+        log.SetFormatter(&log.TextFormatter{
+                DisableColors: true,
+                FullTimestamp: true,
+        })
+```
+
+#### Logging Method Name
+
+If you wish to add the calling method as a field, instruct the logger via:
+```go
+log.SetReportCaller(true)
+```
+This adds the caller as 'method' like so:
+
+```json
+{"animal":"penguin","level":"fatal","method":"github.com/sirupsen/arcticcreatures.migrate","msg":"a penguin swims by",
+"time":"2014-03-10 19:57:38.562543129 -0400 EDT"}
+```
+
+```text
+time="2015-03-26T01:27:38-04:00" level=fatal method=github.com/sirupsen/arcticcreatures.migrate msg="a penguin swims by" animal=penguin
+```
+Note that this does add measurable overhead - the cost will depend on the version of Go, but is
+between 20 and 40% in recent tests with 1.6 and 1.7.  You can validate this in your
+environment via benchmarks:
+```
+go test -bench=.*CallerTracing
+```
+
+
+#### Case-sensitivity
+
+The organization's name was changed to lower-case--and this will not be changed
+back. If you are getting import conflicts due to case sensitivity, please use
+the lower-case import: `github.com/sirupsen/logrus`.
+
+#### Example
+
+The simplest way to use Logrus is simply the package-level exported logger:
+
+```go
+package main
+
+import (
+  log "github.com/sirupsen/logrus"
+)
+
+func main() {
+  log.WithFields(log.Fields{
+    "animal": "walrus",
+  }).Info("A walrus appears")
+}
+```
+
+Note that it's completely api-compatible with the stdlib logger, so you can
+replace your `log` imports everywhere with `log "github.com/sirupsen/logrus"`
+and you'll now have the flexibility of Logrus. You can customize it all you
+want:
+
+```go
+package main
+
+import (
+  "os"
+  log "github.com/sirupsen/logrus"
+)
+
+func init() {
+  // Log as JSON instead of the default ASCII formatter.
+  log.SetFormatter(&log.JSONFormatter{})
+
+  // Output to stdout instead of the default stderr
+  // Can be any io.Writer, see below for File example
+  log.SetOutput(os.Stdout)
+
+  // Only log the warning severity or above.
+  log.SetLevel(log.WarnLevel)
+}
+
+func main() {
+  log.WithFields(log.Fields{
+    "animal": "walrus",
+    "size":   10,
+  }).Info("A group of walrus emerges from the ocean")
+
+  log.WithFields(log.Fields{
+    "omg":    true,
+    "number": 122,
+  }).Warn("The group's number increased tremendously!")
+
+  log.WithFields(log.Fields{
+    "omg":    true,
+    "number": 100,
+  }).Fatal("The ice breaks!")
+
+  // A common pattern is to re-use fields between logging statements by re-using
+  // the logrus.Entry returned from WithFields()
+  contextLogger := log.WithFields(log.Fields{
+    "common": "this is a common field",
+    "other": "I also should be logged always",
+  })
+
+  contextLogger.Info("I'll be logged with common and other field")
+  contextLogger.Info("Me too")
+}
+```
+
+For more advanced usage such as logging to multiple locations from the same
+application, you can also create an instance of the `logrus` Logger:
+
+```go
+package main
+
+import (
+  "os"
+  "github.com/sirupsen/logrus"
+)
+
+// Create a new instance of the logger. You can have any number of instances.
+var log = logrus.New()
+
+func main() {
+  // The API for setting attributes is a little different than the package level
+  // exported logger. See Godoc.
+  log.Out = os.Stdout
+
+  // You could set this to any `io.Writer` such as a file
+  // file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+  // if err == nil {
+  //  log.Out = file
+  // } else {
+  //  log.Info("Failed to log to file, using default stderr")
+  // }
+
+  log.WithFields(logrus.Fields{
+    "animal": "walrus",
+    "size":   10,
+  }).Info("A group of walrus emerges from the ocean")
+}
+```
+
+#### Fields
+
+Logrus encourages careful, structured logging through logging fields instead of
+long, unparseable error messages. For example, instead of: `log.Fatalf("Failed
+to send event %s to topic %s with key %d")`, you should log the much more
+discoverable:
+
+```go
+log.WithFields(log.Fields{
+  "event": event,
+  "topic": topic,
+  "key": key,
+}).Fatal("Failed to send event")
+```
+
+We've found this API forces you to think about logging in a way that produces
+much more useful logging messages. We've been in countless situations where just
+a single added field to a log statement that was already there would've saved us
+hours. The `WithFields` call is optional.
+
+In general, with Logrus using any of the `printf`-family functions should be
+seen as a hint you should add a field, however, you can still use the
+`printf`-family functions with Logrus.
+
+#### Default Fields
+
+Often it's helpful to have fields _always_ attached to log statements in an
+application or parts of one. For example, you may want to always log the
+`request_id` and `user_ip` in the context of a request. Instead of writing
+`log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip})` on
+every line, you can create a `logrus.Entry` to pass around instead:
+
+```go
+requestLogger := log.WithFields(log.Fields{"request_id": request_id, "user_ip": user_ip})
+requestLogger.Info("something happened on that request") # will log request_id and user_ip
+requestLogger.Warn("something not great happened")
+```
+
+#### Hooks
+
+You can add hooks for logging levels. For example to send errors to an exception
+tracking service on `Error`, `Fatal` and `Panic`, info to StatsD or log to
+multiple places simultaneously, e.g. syslog.
+
+Logrus comes with [built-in hooks](hooks/). Add those, or your custom hook, in
+`init`:
+
+```go
+import (
+  log "github.com/sirupsen/logrus"
+  "gopkg.in/gemnasium/logrus-airbrake-hook.v2" // the package is named "airbrake"
+  logrus_syslog "github.com/sirupsen/logrus/hooks/syslog"
+  "log/syslog"
+)
+
+func init() {
+
+  // Use the Airbrake hook to report errors that have Error severity or above to
+  // an exception tracker. You can create custom hooks, see the Hooks section.
+  log.AddHook(airbrake.NewHook(123, "xyz", "production"))
+
+  hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
+  if err != nil {
+    log.Error("Unable to connect to local syslog daemon")
+  } else {
+    log.AddHook(hook)
+  }
+}
+```
+Note: Syslog hook also support connecting to local syslog (Ex. "/dev/log" or "/var/run/syslog" or "/var/run/log"). For the detail, please check the [syslog hook README](hooks/syslog/README.md).
+
+A list of currently known service hooks can be found in this wiki [page](https://github.com/sirupsen/logrus/wiki/Hooks)
+
+
+#### Level logging
+
+Logrus has seven logging levels: Trace, Debug, Info, Warning, Error, Fatal and Panic.
+
+```go
+log.Trace("Something very low level.")
+log.Debug("Useful debugging information.")
+log.Info("Something noteworthy happened!")
+log.Warn("You should probably take a look at this.")
+log.Error("Something failed but I'm not quitting.")
+// Calls os.Exit(1) after logging
+log.Fatal("Bye.")
+// Calls panic() after logging
+log.Panic("I'm bailing.")
+```
+
+You can set the logging level on a `Logger`, then it will only log entries with
+that severity or anything above it:
+
+```go
+// Will log anything that is info or above (warn, error, fatal, panic). Default.
+log.SetLevel(log.InfoLevel)
+```
+
+It may be useful to set `log.Level = logrus.DebugLevel` in a debug or verbose
+environment if your application has that.
+
+Note: If you want different log levels for global (`log.SetLevel(...)`) and syslog logging, please check the [syslog hook README](hooks/syslog/README.md#different-log-levels-for-local-and-remote-logging).
+
+#### Entries
+
+Besides the fields added with `WithField` or `WithFields` some fields are
+automatically added to all logging events:
+
+1. `time`. The timestamp when the entry was created.
+2. `msg`. The logging message passed to `{Info,Warn,Error,Fatal,Panic}` after
+   the `AddFields` call. E.g. `Failed to send event.`
+3. `level`. The logging level. E.g. `info`.
+
+#### Environments
+
+Logrus has no notion of environment.
+
+If you wish for hooks and formatters to only be used in specific environments,
+you should handle that yourself. For example, if your application has a global
+variable `Environment`, which is a string representation of the environment you
+could do:
+
+```go
+import (
+  log "github.com/sirupsen/logrus"
+)
+
+func init() {
+  // do something here to set environment depending on an environment variable
+  // or command-line flag
+  if Environment == "production" {
+    log.SetFormatter(&log.JSONFormatter{})
+  } else {
+    // The TextFormatter is default, you don't actually have to do this.
+    log.SetFormatter(&log.TextFormatter{})
+  }
+}
+```
+
+This configuration is how `logrus` was intended to be used, but JSON in
+production is mostly only useful if you do log aggregation with tools like
+Splunk or Logstash.
+
+#### Formatters
+
+The built-in logging formatters are:
+
+* `logrus.TextFormatter`. Logs the event in colors if stdout is a tty, otherwise
+  without colors.
+  * *Note:* to force colored output when there is no TTY, set the `ForceColors`
+    field to `true`.  To force no colored output even if there is a TTY  set the
+    `DisableColors` field to `true`. For Windows, see
+    [github.com/mattn/go-colorable](https://github.com/mattn/go-colorable).
+  * When colors are enabled, levels are truncated to 4 characters by default. To disable
+    truncation set the `DisableLevelTruncation` field to `true`.
+  * When outputting to a TTY, it's often helpful to visually scan down a column where all the levels are the same width. Setting the `PadLevelText` field to `true` enables this behavior, by adding padding to the level text.
+  * All options are listed in the [generated docs](https://godoc.org/github.com/sirupsen/logrus#TextFormatter).
+* `logrus.JSONFormatter`. Logs fields as JSON.
+  * All options are listed in the [generated docs](https://godoc.org/github.com/sirupsen/logrus#JSONFormatter).
+
+Third party logging formatters:
+
+* [`FluentdFormatter`](https://github.com/joonix/log). Formats entries that can be parsed by Kubernetes and Google Container Engine.
+* [`GELF`](https://github.com/fabienm/go-logrus-formatters). Formats entries so they comply to Graylog's [GELF 1.1 specification](http://docs.graylog.org/en/2.4/pages/gelf.html).
+* [`logstash`](https://github.com/bshuster-repo/logrus-logstash-hook). Logs fields as [Logstash](http://logstash.net) Events.
+* [`prefixed`](https://github.com/x-cray/logrus-prefixed-formatter). Displays log entry source along with alternative layout.
+* [`zalgo`](https://github.com/aybabtme/logzalgo). Invoking the Power of Zalgo.
+* [`nested-logrus-formatter`](https://github.com/antonfisher/nested-logrus-formatter). Converts logrus fields to a nested structure.
+* [`powerful-logrus-formatter`](https://github.com/zput/zxcTool). get fileName, log's line number and the latest function's name when print log; Sava log to files.
+* [`caption-json-formatter`](https://github.com/nolleh/caption_json_formatter). logrus's message json formatter with human-readable caption added.
+
+You can define your formatter by implementing the `Formatter` interface,
+requiring a `Format` method. `Format` takes an `*Entry`. `entry.Data` is a
+`Fields` type (`map[string]interface{}`) with all your fields as well as the
+default ones (see Entries section above):
+
+```go
+type MyJSONFormatter struct {
+}
+
+log.SetFormatter(new(MyJSONFormatter))
+
+func (f *MyJSONFormatter) Format(entry *Entry) ([]byte, error) {
+  // Note this doesn't include Time, Level and Message which are available on
+  // the Entry. Consult `godoc` on information about those fields or read the
+  // source of the official loggers.
+  serialized, err := json.Marshal(entry.Data)
+    if err != nil {
+      return nil, fmt.Errorf("Failed to marshal fields to JSON, %w", err)
+    }
+  return append(serialized, '\n'), nil
+}
+```
+
+#### Logger as an `io.Writer`
+
+Logrus can be transformed into an `io.Writer`. That writer is the end of an `io.Pipe` and it is your responsibility to close it.
+
+```go
+w := logger.Writer()
+defer w.Close()
+
+srv := http.Server{
+    // create a stdlib log.Logger that writes to
+    // logrus.Logger.
+    ErrorLog: log.New(w, "", 0),
+}
+```
+
+Each line written to that writer will be printed the usual way, using formatters
+and hooks. The level for those entries is `info`.
+
+This means that we can override the standard library logger easily:
+
+```go
+logger := logrus.New()
+logger.Formatter = &logrus.JSONFormatter{}
+
+// Use logrus for standard log output
+// Note that `log` here references stdlib's log
+// Not logrus imported under the name `log`.
+log.SetOutput(logger.Writer())
+```
+
+#### Rotation
+
+Log rotation is not provided with Logrus. Log rotation should be done by an
+external program (like `logrotate(8)`) that can compress and delete old log
+entries. It should not be a feature of the application-level logger.
+
+#### Tools
+
+| Tool | Description |
+| ---- | ----------- |
+|[Logrus Mate](https://github.com/gogap/logrus_mate)|Logrus mate is a tool for Logrus to manage loggers, you can initial logger's level, hook and formatter by config file, the logger will be generated with different configs in different environments.|
+|[Logrus Viper Helper](https://github.com/heirko/go-contrib/tree/master/logrusHelper)|An Helper around Logrus to wrap with spf13/Viper to load configuration with fangs! And to simplify Logrus configuration use some behavior of [Logrus Mate](https://github.com/gogap/logrus_mate). [sample](https://github.com/heirko/iris-contrib/blob/master/middleware/logrus-logger/example) |
+
+#### Testing
+
+Logrus has a built in facility for asserting the presence of log messages. This is implemented through the `test` hook and provides:
+
+* decorators for existing logger (`test.NewLocal` and `test.NewGlobal`) which basically just adds the `test` hook
+* a test logger (`test.NewNullLogger`) that just records log messages (and does not output any):
+
+```go
+import(
+  "github.com/sirupsen/logrus"
+  "github.com/sirupsen/logrus/hooks/test"
+  "github.com/stretchr/testify/assert"
+  "testing"
+)
+
+func TestSomething(t*testing.T){
+  logger, hook := test.NewNullLogger()
+  logger.Error("Helloerror")
+
+  assert.Equal(t, 1, len(hook.Entries))
+  assert.Equal(t, logrus.ErrorLevel, hook.LastEntry().Level)
+  assert.Equal(t, "Helloerror", hook.LastEntry().Message)
+
+  hook.Reset()
+  assert.Nil(t, hook.LastEntry())
+}
+```
+
+#### Fatal handlers
+
+Logrus can register one or more functions that will be called when any `fatal`
+level message is logged. The registered handlers will be executed before
+logrus performs an `os.Exit(1)`. This behavior may be helpful if callers need
+to gracefully shutdown. Unlike a `panic("Something went wrong...")` call which can be intercepted with a deferred `recover` a call to `os.Exit(1)` can not be intercepted.
+
+```
+...
+handler := func() {
+  // gracefully shutdown something...
+}
+logrus.RegisterExitHandler(handler)
+...
+```
+
+#### Thread safety
+
+By default, Logger is protected by a mutex for concurrent writes. The mutex is held when calling hooks and writing logs.
+If you are sure such locking is not needed, you can call logger.SetNoLock() to disable the locking.
+
+Situation when locking is not needed includes:
+
+* You have no hooks registered, or hooks calling is already thread-safe.
+
+* Writing to logger.Out is already thread-safe, for example:
+
+  1) logger.Out is protected by locks.
+
+  2) logger.Out is an os.File handler opened with `O_APPEND` flag, and every write is smaller than 4k. (This allows multi-thread/multi-process writing)
+
+     (Refer to http://www.notthewizard.com/2014/06/17/are-files-appends-really-atomic/)
diff --git a/vendor/github.com/sirupsen/logrus/alt_exit.go b/vendor/github.com/sirupsen/logrus/alt_exit.go
new file mode 100644
index 0000000..8fd189e
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/alt_exit.go
@@ -0,0 +1,76 @@
+package logrus
+
+// The following code was sourced and modified from the
+// https://github.com/tebeka/atexit package governed by the following license:
+//
+// Copyright (c) 2012 Miki Tebeka <[email protected]>.
+//
+// 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.
+
+import (
+        "fmt"
+        "os"
+)
+
+var handlers = []func(){}
+
+func runHandler(handler func()) {
+        defer func() {
+                if err := recover(); err != nil {
+                        fmt.Fprintln(os.Stderr, "Error: Logrus exit handler error:", err)
+                }
+        }()
+
+        handler()
+}
+
+func runHandlers() {
+        for _, handler := range handlers {
+                runHandler(handler)
+        }
+}
+
+// Exit runs all the Logrus atexit handlers and then terminates the program using os.Exit(code)
+func Exit(code int) {
+        runHandlers()
+        os.Exit(code)
+}
+
+// RegisterExitHandler appends a Logrus Exit handler to the list of handlers,
+// call logrus.Exit to invoke all handlers. The handlers will also be invoked when
+// any Fatal log entry is made.
+//
+// This method is useful when a caller wishes to use logrus to log a fatal
+// message but also needs to gracefully shutdown. An example usecase could be
+// closing database connections, or sending a alert that the application is
+// closing.
+func RegisterExitHandler(handler func()) {
+        handlers = append(handlers, handler)
+}
+
+// DeferExitHandler prepends a Logrus Exit handler to the list of handlers,
+// call logrus.Exit to invoke all handlers. The handlers will also be invoked when
+// any Fatal log entry is made.
+//
+// This method is useful when a caller wishes to use logrus to log a fatal
+// message but also needs to gracefully shutdown. An example usecase could be
+// closing database connections, or sending a alert that the application is
+// closing.
+func DeferExitHandler(handler func()) {
+        handlers = append([]func(){handler}, handlers...)
+}
diff --git a/vendor/github.com/sirupsen/logrus/appveyor.yml b/vendor/github.com/sirupsen/logrus/appveyor.yml
new file mode 100644
index 0000000..df9d65c
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/appveyor.yml
@@ -0,0 +1,14 @@
+version: "{build}"
+platform: x64
+clone_folder: c:\gopath\src\github.com\sirupsen\logrus
+environment:
+  GOPATH: c:\gopath
+branches:
+  only:
+    - master
+install:
+  - set PATH=%GOPATH%\bin;c:\go\bin;%PATH%
+  - go version
+build_script:
+  - go get -t
+  - go test
diff --git a/vendor/github.com/sirupsen/logrus/buffer_pool.go b/vendor/github.com/sirupsen/logrus/buffer_pool.go
new file mode 100644
index 0000000..c7787f7
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/buffer_pool.go
@@ -0,0 +1,43 @@
+package logrus
+
+import (
+        "bytes"
+        "sync"
+)
+
+var (
+        bufferPool BufferPool
+)
+
+type BufferPool interface {
+        Put(*bytes.Buffer)
+        Get() *bytes.Buffer
+}
+
+type defaultPool struct {
+        pool *sync.Pool
+}
+
+func (p *defaultPool) Put(buf *bytes.Buffer) {
+        p.pool.Put(buf)
+}
+
+func (p *defaultPool) Get() *bytes.Buffer {
+        return p.pool.Get().(*bytes.Buffer)
+}
+
+// SetBufferPool allows to replace the default logrus buffer pool
+// to better meets the specific needs of an application.
+func SetBufferPool(bp BufferPool) {
+        bufferPool = bp
+}
+
+func init() {
+        SetBufferPool(&defaultPool{
+                pool: &sync.Pool{
+                        New: func() interface{} {
+                                return new(bytes.Buffer)
+                        },
+                },
+        })
+}
diff --git a/vendor/github.com/sirupsen/logrus/doc.go b/vendor/github.com/sirupsen/logrus/doc.go
new file mode 100644
index 0000000..da67aba
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/doc.go
@@ -0,0 +1,26 @@
+/*
+Package logrus is a structured logger for Go, completely API compatible with the standard library logger.
+
+
+The simplest way to use Logrus is simply the package-level exported logger:
+
+  package main
+
+  import (
+    log "github.com/sirupsen/logrus"
+  )
+
+  func main() {
+    log.WithFields(log.Fields{
+      "animal": "walrus",
+      "number": 1,
+      "size":   10,
+    }).Info("A walrus appears")
+  }
+
+Output:
+  time="2015-09-07T08:48:33Z" level=info msg="A walrus appears" animal=walrus number=1 size=10
+
+For a full guide visit https://github.com/sirupsen/logrus
+*/
+package logrus
diff --git a/vendor/github.com/sirupsen/logrus/entry.go b/vendor/github.com/sirupsen/logrus/entry.go
new file mode 100644
index 0000000..71cdbbc
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/entry.go
@@ -0,0 +1,442 @@
+package logrus
+
+import (
+        "bytes"
+        "context"
+        "fmt"
+        "os"
+        "reflect"
+        "runtime"
+        "strings"
+        "sync"
+        "time"
+)
+
+var (
+
+        // qualified package name, cached at first use
+        logrusPackage string
+
+        // Positions in the call stack when tracing to report the calling method
+        minimumCallerDepth int
+
+        // Used for caller information initialisation
+        callerInitOnce sync.Once
+)
+
+const (
+        maximumCallerDepth int = 25
+        knownLogrusFrames  int = 4
+)
+
+func init() {
+        // start at the bottom of the stack before the package-name cache is primed
+        minimumCallerDepth = 1
+}
+
+// Defines the key when adding errors using WithError.
+var ErrorKey = "error"
+
+// An entry is the final or intermediate Logrus logging entry. It contains all
+// the fields passed with WithField{,s}. It's finally logged when Trace, Debug,
+// Info, Warn, Error, Fatal or Panic is called on it. These objects can be
+// reused and passed around as much as you wish to avoid field duplication.
+type Entry struct {
+        Logger *Logger
+
+        // Contains all the fields set by the user.
+        Data Fields
+
+        // Time at which the log entry was created
+        Time time.Time
+
+        // Level the log entry was logged at: Trace, Debug, Info, Warn, Error, Fatal or Panic
+        // This field will be set on entry firing and the value will be equal to the one in Logger struct field.
+        Level Level
+
+        // Calling method, with package name
+        Caller *runtime.Frame
+
+        // Message passed to Trace, Debug, Info, Warn, Error, Fatal or Panic
+        Message string
+
+        // When formatter is called in entry.log(), a Buffer may be set to entry
+        Buffer *bytes.Buffer
+
+        // Contains the context set by the user. Useful for hook processing etc.
+        Context context.Context
+
+        // err may contain a field formatting error
+        err string
+}
+
+func NewEntry(logger *Logger) *Entry {
+        return &Entry{
+                Logger: logger,
+                // Default is three fields, plus one optional.  Give a little extra room.
+                Data: make(Fields, 6),
+        }
+}
+
+func (entry *Entry) Dup() *Entry {
+        data := make(Fields, len(entry.Data))
+        for k, v := range entry.Data {
+                data[k] = v
+        }
+        return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, Context: entry.Context, err: entry.err}
+}
+
+// Returns the bytes representation of this entry from the formatter.
+func (entry *Entry) Bytes() ([]byte, error) {
+        return entry.Logger.Formatter.Format(entry)
+}
+
+// Returns the string representation from the reader and ultimately the
+// formatter.
+func (entry *Entry) String() (string, error) {
+        serialized, err := entry.Bytes()
+        if err != nil {
+                return "", err
+        }
+        str := string(serialized)
+        return str, nil
+}
+
+// Add an error as single field (using the key defined in ErrorKey) to the Entry.
+func (entry *Entry) WithError(err error) *Entry {
+        return entry.WithField(ErrorKey, err)
+}
+
+// Add a context to the Entry.
+func (entry *Entry) WithContext(ctx context.Context) *Entry {
+        dataCopy := make(Fields, len(entry.Data))
+        for k, v := range entry.Data {
+                dataCopy[k] = v
+        }
+        return &Entry{Logger: entry.Logger, Data: dataCopy, Time: entry.Time, err: entry.err, Context: ctx}
+}
+
+// Add a single field to the Entry.
+func (entry *Entry) WithField(key string, value interface{}) *Entry {
+        return entry.WithFields(Fields{key: value})
+}
+
+// Add a map of fields to the Entry.
+func (entry *Entry) WithFields(fields Fields) *Entry {
+        data := make(Fields, len(entry.Data)+len(fields))
+        for k, v := range entry.Data {
+                data[k] = v
+        }
+        fieldErr := entry.err
+        for k, v := range fields {
+                isErrField := false
+                if t := reflect.TypeOf(v); t != nil {
+                        switch {
+                        case t.Kind() == reflect.Func, t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Func:
+                                isErrField = true
+                        }
+                }
+                if isErrField {
+                        tmp := fmt.Sprintf("can not add field %q", k)
+                        if fieldErr != "" {
+                                fieldErr = entry.err + ", " + tmp
+                        } else {
+                                fieldErr = tmp
+                        }
+                } else {
+                        data[k] = v
+                }
+        }
+        return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, err: fieldErr, Context: entry.Context}
+}
+
+// Overrides the time of the Entry.
+func (entry *Entry) WithTime(t time.Time) *Entry {
+        dataCopy := make(Fields, len(entry.Data))
+        for k, v := range entry.Data {
+                dataCopy[k] = v
+        }
+        return &Entry{Logger: entry.Logger, Data: dataCopy, Time: t, err: entry.err, Context: entry.Context}
+}
+
+// getPackageName reduces a fully qualified function name to the package name
+// There really ought to be to be a better way...
+func getPackageName(f string) string {
+        for {
+                lastPeriod := strings.LastIndex(f, ".")
+                lastSlash := strings.LastIndex(f, "/")
+                if lastPeriod > lastSlash {
+                        f = f[:lastPeriod]
+                } else {
+                        break
+                }
+        }
+
+        return f
+}
+
+// getCaller retrieves the name of the first non-logrus calling function
+func getCaller() *runtime.Frame {
+        // cache this package's fully-qualified name
+        callerInitOnce.Do(func() {
+                pcs := make([]uintptr, maximumCallerDepth)
+                _ = runtime.Callers(0, pcs)
+
+                // dynamic get the package name and the minimum caller depth
+                for i := 0; i < maximumCallerDepth; i++ {
+                        funcName := runtime.FuncForPC(pcs[i]).Name()
+                        if strings.Contains(funcName, "getCaller") {
+                                logrusPackage = getPackageName(funcName)
+                                break
+                        }
+                }
+
+                minimumCallerDepth = knownLogrusFrames
+        })
+
+        // Restrict the lookback frames to avoid runaway lookups
+        pcs := make([]uintptr, maximumCallerDepth)
+        depth := runtime.Callers(minimumCallerDepth, pcs)
+        frames := runtime.CallersFrames(pcs[:depth])
+
+        for f, again := frames.Next(); again; f, again = frames.Next() {
+                pkg := getPackageName(f.Function)
+
+                // If the caller isn't part of this package, we're done
+                if pkg != logrusPackage {
+                        return &f //nolint:scopelint
+                }
+        }
+
+        // if we got here, we failed to find the caller's context
+        return nil
+}
+
+func (entry Entry) HasCaller() (has bool) {
+        return entry.Logger != nil &&
+                entry.Logger.ReportCaller &&
+                entry.Caller != nil
+}
+
+func (entry *Entry) log(level Level, msg string) {
+        var buffer *bytes.Buffer
+
+        newEntry := entry.Dup()
+
+        if newEntry.Time.IsZero() {
+                newEntry.Time = time.Now()
+        }
+
+        newEntry.Level = level
+        newEntry.Message = msg
+
+        newEntry.Logger.mu.Lock()
+        reportCaller := newEntry.Logger.ReportCaller
+        bufPool := newEntry.getBufferPool()
+        newEntry.Logger.mu.Unlock()
+
+        if reportCaller {
+                newEntry.Caller = getCaller()
+        }
+
+        newEntry.fireHooks()
+        buffer = bufPool.Get()
+        defer func() {
+                newEntry.Buffer = nil
+                buffer.Reset()
+                bufPool.Put(buffer)
+        }()
+        buffer.Reset()
+        newEntry.Buffer = buffer
+
+        newEntry.write()
+
+        newEntry.Buffer = nil
+
+        // To avoid Entry#log() returning a value that only would make sense for
+        // panic() to use in Entry#Panic(), we avoid the allocation by checking
+        // directly here.
+        if level <= PanicLevel {
+                panic(newEntry)
+        }
+}
+
+func (entry *Entry) getBufferPool() (pool BufferPool) {
+        if entry.Logger.BufferPool != nil {
+                return entry.Logger.BufferPool
+        }
+        return bufferPool
+}
+
+func (entry *Entry) fireHooks() {
+        var tmpHooks LevelHooks
+        entry.Logger.mu.Lock()
+        tmpHooks = make(LevelHooks, len(entry.Logger.Hooks))
+        for k, v := range entry.Logger.Hooks {
+                tmpHooks[k] = v
+        }
+        entry.Logger.mu.Unlock()
+
+        err := tmpHooks.Fire(entry.Level, entry)
+        if err != nil {
+                fmt.Fprintf(os.Stderr, "Failed to fire hook: %v\n", err)
+        }
+}
+
+func (entry *Entry) write() {
+        entry.Logger.mu.Lock()
+        defer entry.Logger.mu.Unlock()
+        serialized, err := entry.Logger.Formatter.Format(entry)
+        if err != nil {
+                fmt.Fprintf(os.Stderr, "Failed to obtain reader, %v\n", err)
+                return
+        }
+        if _, err := entry.Logger.Out.Write(serialized); err != nil {
+                fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err)
+        }
+}
+
+// Log will log a message at the level given as parameter.
+// Warning: using Log at Panic or Fatal level will not respectively Panic nor Exit.
+// For this behaviour Entry.Panic or Entry.Fatal should be used instead.
+func (entry *Entry) Log(level Level, args ...interface{}) {
+        if entry.Logger.IsLevelEnabled(level) {
+                entry.log(level, fmt.Sprint(args...))
+        }
+}
+
+func (entry *Entry) Trace(args ...interface{}) {
+        entry.Log(TraceLevel, args...)
+}
+
+func (entry *Entry) Debug(args ...interface{}) {
+        entry.Log(DebugLevel, args...)
+}
+
+func (entry *Entry) Print(args ...interface{}) {
+        entry.Info(args...)
+}
+
+func (entry *Entry) Info(args ...interface{}) {
+        entry.Log(InfoLevel, args...)
+}
+
+func (entry *Entry) Warn(args ...interface{}) {
+        entry.Log(WarnLevel, args...)
+}
+
+func (entry *Entry) Warning(args ...interface{}) {
+        entry.Warn(args...)
+}
+
+func (entry *Entry) Error(args ...interface{}) {
+        entry.Log(ErrorLevel, args...)
+}
+
+func (entry *Entry) Fatal(args ...interface{}) {
+        entry.Log(FatalLevel, args...)
+        entry.Logger.Exit(1)
+}
+
+func (entry *Entry) Panic(args ...interface{}) {
+        entry.Log(PanicLevel, args...)
+}
+
+// Entry Printf family functions
+
+func (entry *Entry) Logf(level Level, format string, args ...interface{}) {
+        if entry.Logger.IsLevelEnabled(level) {
+                entry.Log(level, fmt.Sprintf(format, args...))
+        }
+}
+
+func (entry *Entry) Tracef(format string, args ...interface{}) {
+        entry.Logf(TraceLevel, format, args...)
+}
+
+func (entry *Entry) Debugf(format string, args ...interface{}) {
+        entry.Logf(DebugLevel, format, args...)
+}
+
+func (entry *Entry) Infof(format string, args ...interface{}) {
+        entry.Logf(InfoLevel, format, args...)
+}
+
+func (entry *Entry) Printf(format string, args ...interface{}) {
+        entry.Infof(format, args...)
+}
+
+func (entry *Entry) Warnf(format string, args ...interface{}) {
+        entry.Logf(WarnLevel, format, args...)
+}
+
+func (entry *Entry) Warningf(format string, args ...interface{}) {
+        entry.Warnf(format, args...)
+}
+
+func (entry *Entry) Errorf(format string, args ...interface{}) {
+        entry.Logf(ErrorLevel, format, args...)
+}
+
+func (entry *Entry) Fatalf(format string, args ...interface{}) {
+        entry.Logf(FatalLevel, format, args...)
+        entry.Logger.Exit(1)
+}
+
+func (entry *Entry) Panicf(format string, args ...interface{}) {
+        entry.Logf(PanicLevel, format, args...)
+}
+
+// Entry Println family functions
+
+func (entry *Entry) Logln(level Level, args ...interface{}) {
+        if entry.Logger.IsLevelEnabled(level) {
+                entry.Log(level, entry.sprintlnn(args...))
+        }
+}
+
+func (entry *Entry) Traceln(args ...interface{}) {
+        entry.Logln(TraceLevel, args...)
+}
+
+func (entry *Entry) Debugln(args ...interface{}) {
+        entry.Logln(DebugLevel, args...)
+}
+
+func (entry *Entry) Infoln(args ...interface{}) {
+        entry.Logln(InfoLevel, args...)
+}
+
+func (entry *Entry) Println(args ...interface{}) {
+        entry.Infoln(args...)
+}
+
+func (entry *Entry) Warnln(args ...interface{}) {
+        entry.Logln(WarnLevel, args...)
+}
+
+func (entry *Entry) Warningln(args ...interface{}) {
+        entry.Warnln(args...)
+}
+
+func (entry *Entry) Errorln(args ...interface{}) {
+        entry.Logln(ErrorLevel, args...)
+}
+
+func (entry *Entry) Fatalln(args ...interface{}) {
+        entry.Logln(FatalLevel, args...)
+        entry.Logger.Exit(1)
+}
+
+func (entry *Entry) Panicln(args ...interface{}) {
+        entry.Logln(PanicLevel, args...)
+}
+
+// Sprintlnn => Sprint no newline. This is to get the behavior of how
+// fmt.Sprintln where spaces are always added between operands, regardless of
+// their type. Instead of vendoring the Sprintln implementation to spare a
+// string allocation, we do the simplest thing.
+func (entry *Entry) sprintlnn(args ...interface{}) string {
+        msg := fmt.Sprintln(args...)
+        return msg[:len(msg)-1]
+}
diff --git a/vendor/github.com/sirupsen/logrus/exported.go b/vendor/github.com/sirupsen/logrus/exported.go
new file mode 100644
index 0000000..017c30c
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/exported.go
@@ -0,0 +1,270 @@
+package logrus
+
+import (
+        "context"
+        "io"
+        "time"
+)
+
+var (
+        // std is the name of the standard logger in stdlib `log`
+        std = New()
+)
+
+func StandardLogger() *Logger {
+        return std
+}
+
+// SetOutput sets the standard logger output.
+func SetOutput(out io.Writer) {
+        std.SetOutput(out)
+}
+
+// SetFormatter sets the standard logger formatter.
+func SetFormatter(formatter Formatter) {
+        std.SetFormatter(formatter)
+}
+
+// SetReportCaller sets whether the standard logger will include the calling
+// method as a field.
+func SetReportCaller(include bool) {
+        std.SetReportCaller(include)
+}
+
+// SetLevel sets the standard logger level.
+func SetLevel(level Level) {
+        std.SetLevel(level)
+}
+
+// GetLevel returns the standard logger level.
+func GetLevel() Level {
+        return std.GetLevel()
+}
+
+// IsLevelEnabled checks if the log level of the standard logger is greater than the level param
+func IsLevelEnabled(level Level) bool {
+        return std.IsLevelEnabled(level)
+}
+
+// AddHook adds a hook to the standard logger hooks.
+func AddHook(hook Hook) {
+        std.AddHook(hook)
+}
+
+// WithError creates an entry from the standard logger and adds an error to it, using the value defined in ErrorKey as key.
+func WithError(err error) *Entry {
+        return std.WithField(ErrorKey, err)
+}
+
+// WithContext creates an entry from the standard logger and adds a context to it.
+func WithContext(ctx context.Context) *Entry {
+        return std.WithContext(ctx)
+}
+
+// WithField creates an entry from the standard logger and adds a field to
+// it. If you want multiple fields, use `WithFields`.
+//
+// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
+// or Panic on the Entry it returns.
+func WithField(key string, value interface{}) *Entry {
+        return std.WithField(key, value)
+}
+
+// WithFields creates an entry from the standard logger and adds multiple
+// fields to it. This is simply a helper for `WithField`, invoking it
+// once for each field.
+//
+// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
+// or Panic on the Entry it returns.
+func WithFields(fields Fields) *Entry {
+        return std.WithFields(fields)
+}
+
+// WithTime creates an entry from the standard logger and overrides the time of
+// logs generated with it.
+//
+// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
+// or Panic on the Entry it returns.
+func WithTime(t time.Time) *Entry {
+        return std.WithTime(t)
+}
+
+// Trace logs a message at level Trace on the standard logger.
+func Trace(args ...interface{}) {
+        std.Trace(args...)
+}
+
+// Debug logs a message at level Debug on the standard logger.
+func Debug(args ...interface{}) {
+        std.Debug(args...)
+}
+
+// Print logs a message at level Info on the standard logger.
+func Print(args ...interface{}) {
+        std.Print(args...)
+}
+
+// Info logs a message at level Info on the standard logger.
+func Info(args ...interface{}) {
+        std.Info(args...)
+}
+
+// Warn logs a message at level Warn on the standard logger.
+func Warn(args ...interface{}) {
+        std.Warn(args...)
+}
+
+// Warning logs a message at level Warn on the standard logger.
+func Warning(args ...interface{}) {
+        std.Warning(args...)
+}
+
+// Error logs a message at level Error on the standard logger.
+func Error(args ...interface{}) {
+        std.Error(args...)
+}
+
+// Panic logs a message at level Panic on the standard logger.
+func Panic(args ...interface{}) {
+        std.Panic(args...)
+}
+
+// Fatal logs a message at level Fatal on the standard logger then the process will exit with status set to 1.
+func Fatal(args ...interface{}) {
+        std.Fatal(args...)
+}
+
+// TraceFn logs a message from a func at level Trace on the standard logger.
+func TraceFn(fn LogFunction) {
+        std.TraceFn(fn)
+}
+
+// DebugFn logs a message from a func at level Debug on the standard logger.
+func DebugFn(fn LogFunction) {
+        std.DebugFn(fn)
+}
+
+// PrintFn logs a message from a func at level Info on the standard logger.
+func PrintFn(fn LogFunction) {
+        std.PrintFn(fn)
+}
+
+// InfoFn logs a message from a func at level Info on the standard logger.
+func InfoFn(fn LogFunction) {
+        std.InfoFn(fn)
+}
+
+// WarnFn logs a message from a func at level Warn on the standard logger.
+func WarnFn(fn LogFunction) {
+        std.WarnFn(fn)
+}
+
+// WarningFn logs a message from a func at level Warn on the standard logger.
+func WarningFn(fn LogFunction) {
+        std.WarningFn(fn)
+}
+
+// ErrorFn logs a message from a func at level Error on the standard logger.
+func ErrorFn(fn LogFunction) {
+        std.ErrorFn(fn)
+}
+
+// PanicFn logs a message from a func at level Panic on the standard logger.
+func PanicFn(fn LogFunction) {
+        std.PanicFn(fn)
+}
+
+// FatalFn logs a message from a func at level Fatal on the standard logger then the process will exit with status set to 1.
+func FatalFn(fn LogFunction) {
+        std.FatalFn(fn)
+}
+
+// Tracef logs a message at level Trace on the standard logger.
+func Tracef(format string, args ...interface{}) {
+        std.Tracef(format, args...)
+}
+
+// Debugf logs a message at level Debug on the standard logger.
+func Debugf(format string, args ...interface{}) {
+        std.Debugf(format, args...)
+}
+
+// Printf logs a message at level Info on the standard logger.
+func Printf(format string, args ...interface{}) {
+        std.Printf(format, args...)
+}
+
+// Infof logs a message at level Info on the standard logger.
+func Infof(format string, args ...interface{}) {
+        std.Infof(format, args...)
+}
+
+// Warnf logs a message at level Warn on the standard logger.
+func Warnf(format string, args ...interface{}) {
+        std.Warnf(format, args...)
+}
+
+// Warningf logs a message at level Warn on the standard logger.
+func Warningf(format string, args ...interface{}) {
+        std.Warningf(format, args...)
+}
+
+// Errorf logs a message at level Error on the standard logger.
+func Errorf(format string, args ...interface{}) {
+        std.Errorf(format, args...)
+}
+
+// Panicf logs a message at level Panic on the standard logger.
+func Panicf(format string, args ...interface{}) {
+        std.Panicf(format, args...)
+}
+
+// Fatalf logs a message at level Fatal on the standard logger then the process will exit with status set to 1.
+func Fatalf(format string, args ...interface{}) {
+        std.Fatalf(format, args...)
+}
+
+// Traceln logs a message at level Trace on the standard logger.
+func Traceln(args ...interface{}) {
+        std.Traceln(args...)
+}
+
+// Debugln logs a message at level Debug on the standard logger.
+func Debugln(args ...interface{}) {
+        std.Debugln(args...)
+}
+
+// Println logs a message at level Info on the standard logger.
+func Println(args ...interface{}) {
+        std.Println(args...)
+}
+
+// Infoln logs a message at level Info on the standard logger.
+func Infoln(args ...interface{}) {
+        std.Infoln(args...)
+}
+
+// Warnln logs a message at level Warn on the standard logger.
+func Warnln(args ...interface{}) {
+        std.Warnln(args...)
+}
+
+// Warningln logs a message at level Warn on the standard logger.
+func Warningln(args ...interface{}) {
+        std.Warningln(args...)
+}
+
+// Errorln logs a message at level Error on the standard logger.
+func Errorln(args ...interface{}) {
+        std.Errorln(args...)
+}
+
+// Panicln logs a message at level Panic on the standard logger.
+func Panicln(args ...interface{}) {
+        std.Panicln(args...)
+}
+
+// Fatalln logs a message at level Fatal on the standard logger then the process will exit with status set to 1.
+func Fatalln(args ...interface{}) {
+        std.Fatalln(args...)
+}
diff --git a/vendor/github.com/sirupsen/logrus/formatter.go b/vendor/github.com/sirupsen/logrus/formatter.go
new file mode 100644
index 0000000..4088837
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/formatter.go
@@ -0,0 +1,78 @@
+package logrus
+
+import "time"
+
+// Default key names for the default fields
+const (
+        defaultTimestampFormat = time.RFC3339
+        FieldKeyMsg            = "msg"
+        FieldKeyLevel          = "level"
+        FieldKeyTime           = "time"
+        FieldKeyLogrusError    = "logrus_error"
+        FieldKeyFunc           = "func"
+        FieldKeyFile           = "file"
+)
+
+// The Formatter interface is used to implement a custom Formatter. It takes an
+// `Entry`. It exposes all the fields, including the default ones:
+//
+// * `entry.Data["msg"]`. The message passed from Info, Warn, Error ..
+// * `entry.Data["time"]`. The timestamp.
+// * `entry.Data["level"]. The level the entry was logged at.
+//
+// Any additional fields added with `WithField` or `WithFields` are also in
+// `entry.Data`. Format is expected to return an array of bytes which are then
+// logged to `logger.Out`.
+type Formatter interface {
+        Format(*Entry) ([]byte, error)
+}
+
+// This is to not silently overwrite `time`, `msg`, `func` and `level` fields when
+// dumping it. If this code wasn't there doing:
+//
+//  logrus.WithField("level", 1).Info("hello")
+//
+// Would just silently drop the user provided level. Instead with this code
+// it'll logged as:
+//
+//  {"level": "info", "fields.level": 1, "msg": "hello", "time": "..."}
+//
+// It's not exported because it's still using Data in an opinionated way. It's to
+// avoid code duplication between the two default formatters.
+func prefixFieldClashes(data Fields, fieldMap FieldMap, reportCaller bool) {
+        timeKey := fieldMap.resolve(FieldKeyTime)
+        if t, ok := data[timeKey]; ok {
+                data["fields."+timeKey] = t
+                delete(data, timeKey)
+        }
+
+        msgKey := fieldMap.resolve(FieldKeyMsg)
+        if m, ok := data[msgKey]; ok {
+                data["fields."+msgKey] = m
+                delete(data, msgKey)
+        }
+
+        levelKey := fieldMap.resolve(FieldKeyLevel)
+        if l, ok := data[levelKey]; ok {
+                data["fields."+levelKey] = l
+                delete(data, levelKey)
+        }
+
+        logrusErrKey := fieldMap.resolve(FieldKeyLogrusError)
+        if l, ok := data[logrusErrKey]; ok {
+                data["fields."+logrusErrKey] = l
+                delete(data, logrusErrKey)
+        }
+
+        // If reportCaller is not set, 'func' will not conflict.
+        if reportCaller {
+                funcKey := fieldMap.resolve(FieldKeyFunc)
+                if l, ok := data[funcKey]; ok {
+                        data["fields."+funcKey] = l
+                }
+                fileKey := fieldMap.resolve(FieldKeyFile)
+                if l, ok := data[fileKey]; ok {
+                        data["fields."+fileKey] = l
+                }
+        }
+}
diff --git a/vendor/github.com/sirupsen/logrus/hooks.go b/vendor/github.com/sirupsen/logrus/hooks.go
new file mode 100644
index 0000000..3f151cd
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/hooks.go
@@ -0,0 +1,34 @@
+package logrus
+
+// A hook to be fired when logging on the logging levels returned from
+// `Levels()` on your implementation of the interface. Note that this is not
+// fired in a goroutine or a channel with workers, you should handle such
+// functionality yourself if your call is non-blocking and you don't wish for
+// the logging calls for levels returned from `Levels()` to block.
+type Hook interface {
+        Levels() []Level
+        Fire(*Entry) error
+}
+
+// Internal type for storing the hooks on a logger instance.
+type LevelHooks map[Level][]Hook
+
+// Add a hook to an instance of logger. This is called with
+// `log.Hooks.Add(new(MyHook))` where `MyHook` implements the `Hook` interface.
+func (hooks LevelHooks) Add(hook Hook) {
+        for _, level := range hook.Levels() {
+                hooks[level] = append(hooks[level], hook)
+        }
+}
+
+// Fire all the hooks for the passed level. Used by `entry.log` to fire
+// appropriate hooks for a log entry.
+func (hooks LevelHooks) Fire(level Level, entry *Entry) error {
+        for _, hook := range hooks[level] {
+                if err := hook.Fire(entry); err != nil {
+                        return err
+                }
+        }
+
+        return nil
+}
diff --git a/vendor/github.com/sirupsen/logrus/json_formatter.go b/vendor/github.com/sirupsen/logrus/json_formatter.go
new file mode 100644
index 0000000..c96dc56
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/json_formatter.go
@@ -0,0 +1,128 @@
+package logrus
+
+import (
+        "bytes"
+        "encoding/json"
+        "fmt"
+        "runtime"
+)
+
+type fieldKey string
+
+// FieldMap allows customization of the key names for default fields.
+type FieldMap map[fieldKey]string
+
+func (f FieldMap) resolve(key fieldKey) string {
+        if k, ok := f[key]; ok {
+                return k
+        }
+
+        return string(key)
+}
+
+// JSONFormatter formats logs into parsable json
+type JSONFormatter struct {
+        // TimestampFormat sets the format used for marshaling timestamps.
+        // The format to use is the same than for time.Format or time.Parse from the standard
+        // library.
+        // The standard Library already provides a set of predefined format.
+        TimestampFormat string
+
+        // DisableTimestamp allows disabling automatic timestamps in output
+        DisableTimestamp bool
+
+        // DisableHTMLEscape allows disabling html escaping in output
+        DisableHTMLEscape bool
+
+        // DataKey allows users to put all the log entry parameters into a nested dictionary at a given key.
+        DataKey string
+
+        // FieldMap allows users to customize the names of keys for default fields.
+        // As an example:
+        // formatter := &JSONFormatter{
+        //      FieldMap: FieldMap{
+        //               FieldKeyTime:  "@timestamp",
+        //               FieldKeyLevel: "@level",
+        //               FieldKeyMsg:   "@message",
+        //               FieldKeyFunc:  "@caller",
+        //    },
+        // }
+        FieldMap FieldMap
+
+        // CallerPrettyfier can be set by the user to modify the content
+        // of the function and file keys in the json data when ReportCaller is
+        // activated. If any of the returned value is the empty string the
+        // corresponding key will be removed from json fields.
+        CallerPrettyfier func(*runtime.Frame) (function string, file string)
+
+        // PrettyPrint will indent all json logs
+        PrettyPrint bool
+}
+
+// Format renders a single log entry
+func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
+        data := make(Fields, len(entry.Data)+4)
+        for k, v := range entry.Data {
+                switch v := v.(type) {
+                case error:
+                        // Otherwise errors are ignored by `encoding/json`
+                        // https://github.com/sirupsen/logrus/issues/137
+                        data[k] = v.Error()
+                default:
+                        data[k] = v
+                }
+        }
+
+        if f.DataKey != "" {
+                newData := make(Fields, 4)
+                newData[f.DataKey] = data
+                data = newData
+        }
+
+        prefixFieldClashes(data, f.FieldMap, entry.HasCaller())
+
+        timestampFormat := f.TimestampFormat
+        if timestampFormat == "" {
+                timestampFormat = defaultTimestampFormat
+        }
+
+        if entry.err != "" {
+                data[f.FieldMap.resolve(FieldKeyLogrusError)] = entry.err
+        }
+        if !f.DisableTimestamp {
+                data[f.FieldMap.resolve(FieldKeyTime)] = entry.Time.Format(timestampFormat)
+        }
+        data[f.FieldMap.resolve(FieldKeyMsg)] = entry.Message
+        data[f.FieldMap.resolve(FieldKeyLevel)] = entry.Level.String()
+        if entry.HasCaller() {
+                funcVal := entry.Caller.Function
+                fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
+                if f.CallerPrettyfier != nil {
+                        funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
+                }
+                if funcVal != "" {
+                        data[f.FieldMap.resolve(FieldKeyFunc)] = funcVal
+                }
+                if fileVal != "" {
+                        data[f.FieldMap.resolve(FieldKeyFile)] = fileVal
+                }
+        }
+
+        var b *bytes.Buffer
+        if entry.Buffer != nil {
+                b = entry.Buffer
+        } else {
+                b = &bytes.Buffer{}
+        }
+
+        encoder := json.NewEncoder(b)
+        encoder.SetEscapeHTML(!f.DisableHTMLEscape)
+        if f.PrettyPrint {
+                encoder.SetIndent("", "  ")
+        }
+        if err := encoder.Encode(data); err != nil {
+                return nil, fmt.Errorf("failed to marshal fields to JSON, %w", err)
+        }
+
+        return b.Bytes(), nil
+}
diff --git a/vendor/github.com/sirupsen/logrus/logger.go b/vendor/github.com/sirupsen/logrus/logger.go
new file mode 100644
index 0000000..5ff0aef
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/logger.go
@@ -0,0 +1,417 @@
+package logrus
+
+import (
+        "context"
+        "io"
+        "os"
+        "sync"
+        "sync/atomic"
+        "time"
+)
+
+// LogFunction For big messages, it can be more efficient to pass a function
+// and only call it if the log level is actually enables rather than
+// generating the log message and then checking if the level is enabled
+type LogFunction func() []interface{}
+
+type Logger struct {
+        // The logs are `io.Copy`'d to this in a mutex. It's common to set this to a
+        // file, or leave it default which is `os.Stderr`. You can also set this to
+        // something more adventurous, such as logging to Kafka.
+        Out io.Writer
+        // Hooks for the logger instance. These allow firing events based on logging
+        // levels and log entries. For example, to send errors to an error tracking
+        // service, log to StatsD or dump the core on fatal errors.
+        Hooks LevelHooks
+        // All log entries pass through the formatter before logged to Out. The
+        // included formatters are `TextFormatter` and `JSONFormatter` for which
+        // TextFormatter is the default. In development (when a TTY is attached) it
+        // logs with colors, but to a file it wouldn't. You can easily implement your
+        // own that implements the `Formatter` interface, see the `README` or included
+        // formatters for examples.
+        Formatter Formatter
+
+        // Flag for whether to log caller info (off by default)
+        ReportCaller bool
+
+        // The logging level the logger should log at. This is typically (and defaults
+        // to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be
+        // logged.
+        Level Level
+        // Used to sync writing to the log. Locking is enabled by Default
+        mu MutexWrap
+        // Reusable empty entry
+        entryPool sync.Pool
+        // Function to exit the application, defaults to `os.Exit()`
+        ExitFunc exitFunc
+        // The buffer pool used to format the log. If it is nil, the default global
+        // buffer pool will be used.
+        BufferPool BufferPool
+}
+
+type exitFunc func(int)
+
+type MutexWrap struct {
+        lock     sync.Mutex
+        disabled bool
+}
+
+func (mw *MutexWrap) Lock() {
+        if !mw.disabled {
+                mw.lock.Lock()
+        }
+}
+
+func (mw *MutexWrap) Unlock() {
+        if !mw.disabled {
+                mw.lock.Unlock()
+        }
+}
+
+func (mw *MutexWrap) Disable() {
+        mw.disabled = true
+}
+
+// Creates a new logger. Configuration should be set by changing `Formatter`,
+// `Out` and `Hooks` directly on the default logger instance. You can also just
+// instantiate your own:
+//
+//    var log = &logrus.Logger{
+//      Out: os.Stderr,
+//      Formatter: new(logrus.TextFormatter),
+//      Hooks: make(logrus.LevelHooks),
+//      Level: logrus.DebugLevel,
+//    }
+//
+// It's recommended to make this a global instance called `log`.
+func New() *Logger {
+        return &Logger{
+                Out:          os.Stderr,
+                Formatter:    new(TextFormatter),
+                Hooks:        make(LevelHooks),
+                Level:        InfoLevel,
+                ExitFunc:     os.Exit,
+                ReportCaller: false,
+        }
+}
+
+func (logger *Logger) newEntry() *Entry {
+        entry, ok := logger.entryPool.Get().(*Entry)
+        if ok {
+                return entry
+        }
+        return NewEntry(logger)
+}
+
+func (logger *Logger) releaseEntry(entry *Entry) {
+        entry.Data = map[string]interface{}{}
+        logger.entryPool.Put(entry)
+}
+
+// WithField allocates a new entry and adds a field to it.
+// Debug, Print, Info, Warn, Error, Fatal or Panic must be then applied to
+// this new returned entry.
+// If you want multiple fields, use `WithFields`.
+func (logger *Logger) WithField(key string, value interface{}) *Entry {
+        entry := logger.newEntry()
+        defer logger.releaseEntry(entry)
+        return entry.WithField(key, value)
+}
+
+// Adds a struct of fields to the log entry. All it does is call `WithField` for
+// each `Field`.
+func (logger *Logger) WithFields(fields Fields) *Entry {
+        entry := logger.newEntry()
+        defer logger.releaseEntry(entry)
+        return entry.WithFields(fields)
+}
+
+// Add an error as single field to the log entry.  All it does is call
+// `WithError` for the given `error`.
+func (logger *Logger) WithError(err error) *Entry {
+        entry := logger.newEntry()
+        defer logger.releaseEntry(entry)
+        return entry.WithError(err)
+}
+
+// Add a context to the log entry.
+func (logger *Logger) WithContext(ctx context.Context) *Entry {
+        entry := logger.newEntry()
+        defer logger.releaseEntry(entry)
+        return entry.WithContext(ctx)
+}
+
+// Overrides the time of the log entry.
+func (logger *Logger) WithTime(t time.Time) *Entry {
+        entry := logger.newEntry()
+        defer logger.releaseEntry(entry)
+        return entry.WithTime(t)
+}
+
+func (logger *Logger) Logf(level Level, format string, args ...interface{}) {
+        if logger.IsLevelEnabled(level) {
+                entry := logger.newEntry()
+                entry.Logf(level, format, args...)
+                logger.releaseEntry(entry)
+        }
+}
+
+func (logger *Logger) Tracef(format string, args ...interface{}) {
+        logger.Logf(TraceLevel, format, args...)
+}
+
+func (logger *Logger) Debugf(format string, args ...interface{}) {
+        logger.Logf(DebugLevel, format, args...)
+}
+
+func (logger *Logger) Infof(format string, args ...interface{}) {
+        logger.Logf(InfoLevel, format, args...)
+}
+
+func (logger *Logger) Printf(format string, args ...interface{}) {
+        entry := logger.newEntry()
+        entry.Printf(format, args...)
+        logger.releaseEntry(entry)
+}
+
+func (logger *Logger) Warnf(format string, args ...interface{}) {
+        logger.Logf(WarnLevel, format, args...)
+}
+
+func (logger *Logger) Warningf(format string, args ...interface{}) {
+        logger.Warnf(format, args...)
+}
+
+func (logger *Logger) Errorf(format string, args ...interface{}) {
+        logger.Logf(ErrorLevel, format, args...)
+}
+
+func (logger *Logger) Fatalf(format string, args ...interface{}) {
+        logger.Logf(FatalLevel, format, args...)
+        logger.Exit(1)
+}
+
+func (logger *Logger) Panicf(format string, args ...interface{}) {
+        logger.Logf(PanicLevel, format, args...)
+}
+
+// Log will log a message at the level given as parameter.
+// Warning: using Log at Panic or Fatal level will not respectively Panic nor Exit.
+// For this behaviour Logger.Panic or Logger.Fatal should be used instead.
+func (logger *Logger) Log(level Level, args ...interface{}) {
+        if logger.IsLevelEnabled(level) {
+                entry := logger.newEntry()
+                entry.Log(level, args...)
+                logger.releaseEntry(entry)
+        }
+}
+
+func (logger *Logger) LogFn(level Level, fn LogFunction) {
+        if logger.IsLevelEnabled(level) {
+                entry := logger.newEntry()
+                entry.Log(level, fn()...)
+                logger.releaseEntry(entry)
+        }
+}
+
+func (logger *Logger) Trace(args ...interface{}) {
+        logger.Log(TraceLevel, args...)
+}
+
+func (logger *Logger) Debug(args ...interface{}) {
+        logger.Log(DebugLevel, args...)
+}
+
+func (logger *Logger) Info(args ...interface{}) {
+        logger.Log(InfoLevel, args...)
+}
+
+func (logger *Logger) Print(args ...interface{}) {
+        entry := logger.newEntry()
+        entry.Print(args...)
+        logger.releaseEntry(entry)
+}
+
+func (logger *Logger) Warn(args ...interface{}) {
+        logger.Log(WarnLevel, args...)
+}
+
+func (logger *Logger) Warning(args ...interface{}) {
+        logger.Warn(args...)
+}
+
+func (logger *Logger) Error(args ...interface{}) {
+        logger.Log(ErrorLevel, args...)
+}
+
+func (logger *Logger) Fatal(args ...interface{}) {
+        logger.Log(FatalLevel, args...)
+        logger.Exit(1)
+}
+
+func (logger *Logger) Panic(args ...interface{}) {
+        logger.Log(PanicLevel, args...)
+}
+
+func (logger *Logger) TraceFn(fn LogFunction) {
+        logger.LogFn(TraceLevel, fn)
+}
+
+func (logger *Logger) DebugFn(fn LogFunction) {
+        logger.LogFn(DebugLevel, fn)
+}
+
+func (logger *Logger) InfoFn(fn LogFunction) {
+        logger.LogFn(InfoLevel, fn)
+}
+
+func (logger *Logger) PrintFn(fn LogFunction) {
+        entry := logger.newEntry()
+        entry.Print(fn()...)
+        logger.releaseEntry(entry)
+}
+
+func (logger *Logger) WarnFn(fn LogFunction) {
+        logger.LogFn(WarnLevel, fn)
+}
+
+func (logger *Logger) WarningFn(fn LogFunction) {
+        logger.WarnFn(fn)
+}
+
+func (logger *Logger) ErrorFn(fn LogFunction) {
+        logger.LogFn(ErrorLevel, fn)
+}
+
+func (logger *Logger) FatalFn(fn LogFunction) {
+        logger.LogFn(FatalLevel, fn)
+        logger.Exit(1)
+}
+
+func (logger *Logger) PanicFn(fn LogFunction) {
+        logger.LogFn(PanicLevel, fn)
+}
+
+func (logger *Logger) Logln(level Level, args ...interface{}) {
+        if logger.IsLevelEnabled(level) {
+                entry := logger.newEntry()
+                entry.Logln(level, args...)
+                logger.releaseEntry(entry)
+        }
+}
+
+func (logger *Logger) Traceln(args ...interface{}) {
+        logger.Logln(TraceLevel, args...)
+}
+
+func (logger *Logger) Debugln(args ...interface{}) {
+        logger.Logln(DebugLevel, args...)
+}
+
+func (logger *Logger) Infoln(args ...interface{}) {
+        logger.Logln(InfoLevel, args...)
+}
+
+func (logger *Logger) Println(args ...interface{}) {
+        entry := logger.newEntry()
+        entry.Println(args...)
+        logger.releaseEntry(entry)
+}
+
+func (logger *Logger) Warnln(args ...interface{}) {
+        logger.Logln(WarnLevel, args...)
+}
+
+func (logger *Logger) Warningln(args ...interface{}) {
+        logger.Warnln(args...)
+}
+
+func (logger *Logger) Errorln(args ...interface{}) {
+        logger.Logln(ErrorLevel, args...)
+}
+
+func (logger *Logger) Fatalln(args ...interface{}) {
+        logger.Logln(FatalLevel, args...)
+        logger.Exit(1)
+}
+
+func (logger *Logger) Panicln(args ...interface{}) {
+        logger.Logln(PanicLevel, args...)
+}
+
+func (logger *Logger) Exit(code int) {
+        runHandlers()
+        if logger.ExitFunc == nil {
+                logger.ExitFunc = os.Exit
+        }
+        logger.ExitFunc(code)
+}
+
+//When file is opened with appending mode, it's safe to
+//write concurrently to a file (within 4k message on Linux).
+//In these cases user can choose to disable the lock.
+func (logger *Logger) SetNoLock() {
+        logger.mu.Disable()
+}
+
+func (logger *Logger) level() Level {
+        return Level(atomic.LoadUint32((*uint32)(&logger.Level)))
+}
+
+// SetLevel sets the logger level.
+func (logger *Logger) SetLevel(level Level) {
+        atomic.StoreUint32((*uint32)(&logger.Level), uint32(level))
+}
+
+// GetLevel returns the logger level.
+func (logger *Logger) GetLevel() Level {
+        return logger.level()
+}
+
+// AddHook adds a hook to the logger hooks.
+func (logger *Logger) AddHook(hook Hook) {
+        logger.mu.Lock()
+        defer logger.mu.Unlock()
+        logger.Hooks.Add(hook)
+}
+
+// IsLevelEnabled checks if the log level of the logger is greater than the level param
+func (logger *Logger) IsLevelEnabled(level Level) bool {
+        return logger.level() >= level
+}
+
+// SetFormatter sets the logger formatter.
+func (logger *Logger) SetFormatter(formatter Formatter) {
+        logger.mu.Lock()
+        defer logger.mu.Unlock()
+        logger.Formatter = formatter
+}
+
+// SetOutput sets the logger output.
+func (logger *Logger) SetOutput(output io.Writer) {
+        logger.mu.Lock()
+        defer logger.mu.Unlock()
+        logger.Out = output
+}
+
+func (logger *Logger) SetReportCaller(reportCaller bool) {
+        logger.mu.Lock()
+        defer logger.mu.Unlock()
+        logger.ReportCaller = reportCaller
+}
+
+// ReplaceHooks replaces the logger hooks and returns the old ones
+func (logger *Logger) ReplaceHooks(hooks LevelHooks) LevelHooks {
+        logger.mu.Lock()
+        oldHooks := logger.Hooks
+        logger.Hooks = hooks
+        logger.mu.Unlock()
+        return oldHooks
+}
+
+// SetBufferPool sets the logger buffer pool.
+func (logger *Logger) SetBufferPool(pool BufferPool) {
+        logger.mu.Lock()
+        defer logger.mu.Unlock()
+        logger.BufferPool = pool
+}
diff --git a/vendor/github.com/sirupsen/logrus/logrus.go b/vendor/github.com/sirupsen/logrus/logrus.go
new file mode 100644
index 0000000..2f16224
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/logrus.go
@@ -0,0 +1,186 @@
+package logrus
+
+import (
+        "fmt"
+        "log"
+        "strings"
+)
+
+// Fields type, used to pass to `WithFields`.
+type Fields map[string]interface{}
+
+// Level type
+type Level uint32
+
+// Convert the Level to a string. E.g. PanicLevel becomes "panic".
+func (level Level) String() string {
+        if b, err := level.MarshalText(); err == nil {
+                return string(b)
+        } else {
+                return "unknown"
+        }
+}
+
+// ParseLevel takes a string level and returns the Logrus log level constant.
+func ParseLevel(lvl string) (Level, error) {
+        switch strings.ToLower(lvl) {
+        case "panic":
+                return PanicLevel, nil
+        case "fatal":
+                return FatalLevel, nil
+        case "error":
+                return ErrorLevel, nil
+        case "warn", "warning":
+                return WarnLevel, nil
+        case "info":
+                return InfoLevel, nil
+        case "debug":
+                return DebugLevel, nil
+        case "trace":
+                return TraceLevel, nil
+        }
+
+        var l Level
+        return l, fmt.Errorf("not a valid logrus Level: %q", lvl)
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler.
+func (level *Level) UnmarshalText(text []byte) error {
+        l, err := ParseLevel(string(text))
+        if err != nil {
+                return err
+        }
+
+        *level = l
+
+        return nil
+}
+
+func (level Level) MarshalText() ([]byte, error) {
+        switch level {
+        case TraceLevel:
+                return []byte("trace"), nil
+        case DebugLevel:
+                return []byte("debug"), nil
+        case InfoLevel:
+                return []byte("info"), nil
+        case WarnLevel:
+                return []byte("warning"), nil
+        case ErrorLevel:
+                return []byte("error"), nil
+        case FatalLevel:
+                return []byte("fatal"), nil
+        case PanicLevel:
+                return []byte("panic"), nil
+        }
+
+        return nil, fmt.Errorf("not a valid logrus level %d", level)
+}
+
+// A constant exposing all logging levels
+var AllLevels = []Level{
+        PanicLevel,
+        FatalLevel,
+        ErrorLevel,
+        WarnLevel,
+        InfoLevel,
+        DebugLevel,
+        TraceLevel,
+}
+
+// These are the different logging levels. You can set the logging level to log
+// on your instance of logger, obtained with `logrus.New()`.
+const (
+        // PanicLevel level, highest level of severity. Logs and then calls panic with the
+        // message passed to Debug, Info, ...
+        PanicLevel Level = iota
+        // FatalLevel level. Logs and then calls `logger.Exit(1)`. It will exit even if the
+        // logging level is set to Panic.
+        FatalLevel
+        // ErrorLevel level. Logs. Used for errors that should definitely be noted.
+        // Commonly used for hooks to send errors to an error tracking service.
+        ErrorLevel
+        // WarnLevel level. Non-critical entries that deserve eyes.
+        WarnLevel
+        // InfoLevel level. General operational entries about what's going on inside the
+        // application.
+        InfoLevel
+        // DebugLevel level. Usually only enabled when debugging. Very verbose logging.
+        DebugLevel
+        // TraceLevel level. Designates finer-grained informational events than the Debug.
+        TraceLevel
+)
+
+// Won't compile if StdLogger can't be realized by a log.Logger
+var (
+        _ StdLogger = &log.Logger{}
+        _ StdLogger = &Entry{}
+        _ StdLogger = &Logger{}
+)
+
+// StdLogger is what your logrus-enabled library should take, that way
+// it'll accept a stdlib logger and a logrus logger. There's no standard
+// interface, this is the closest we get, unfortunately.
+type StdLogger interface {
+        Print(...interface{})
+        Printf(string, ...interface{})
+        Println(...interface{})
+
+        Fatal(...interface{})
+        Fatalf(string, ...interface{})
+        Fatalln(...interface{})
+
+        Panic(...interface{})
+        Panicf(string, ...interface{})
+        Panicln(...interface{})
+}
+
+// The FieldLogger interface generalizes the Entry and Logger types
+type FieldLogger interface {
+        WithField(key string, value interface{}) *Entry
+        WithFields(fields Fields) *Entry
+        WithError(err error) *Entry
+
+        Debugf(format string, args ...interface{})
+        Infof(format string, args ...interface{})
+        Printf(format string, args ...interface{})
+        Warnf(format string, args ...interface{})
+        Warningf(format string, args ...interface{})
+        Errorf(format string, args ...interface{})
+        Fatalf(format string, args ...interface{})
+        Panicf(format string, args ...interface{})
+
+        Debug(args ...interface{})
+        Info(args ...interface{})
+        Print(args ...interface{})
+        Warn(args ...interface{})
+        Warning(args ...interface{})
+        Error(args ...interface{})
+        Fatal(args ...interface{})
+        Panic(args ...interface{})
+
+        Debugln(args ...interface{})
+        Infoln(args ...interface{})
+        Println(args ...interface{})
+        Warnln(args ...interface{})
+        Warningln(args ...interface{})
+        Errorln(args ...interface{})
+        Fatalln(args ...interface{})
+        Panicln(args ...interface{})
+
+        // IsDebugEnabled() bool
+        // IsInfoEnabled() bool
+        // IsWarnEnabled() bool
+        // IsErrorEnabled() bool
+        // IsFatalEnabled() bool
+        // IsPanicEnabled() bool
+}
+
+// Ext1FieldLogger (the first extension to FieldLogger) is superfluous, it is
+// here for consistancy. Do not use. Use Logger or Entry instead.
+type Ext1FieldLogger interface {
+        FieldLogger
+        Tracef(format string, args ...interface{})
+        Trace(args ...interface{})
+        Traceln(args ...interface{})
+}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_appengine.go b/vendor/github.com/sirupsen/logrus/terminal_check_appengine.go
new file mode 100644
index 0000000..2403de9
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_appengine.go
@@ -0,0 +1,11 @@
+// +build appengine
+
+package logrus
+
+import (
+        "io"
+)
+
+func checkIfTerminal(w io.Writer) bool {
+        return true
+}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_bsd.go b/vendor/github.com/sirupsen/logrus/terminal_check_bsd.go
new file mode 100644
index 0000000..4997899
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_bsd.go
@@ -0,0 +1,13 @@
+// +build darwin dragonfly freebsd netbsd openbsd
+// +build !js
+
+package logrus
+
+import "golang.org/x/sys/unix"
+
+const ioctlReadTermios = unix.TIOCGETA
+
+func isTerminal(fd int) bool {
+        _, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
+        return err == nil
+}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_js.go b/vendor/github.com/sirupsen/logrus/terminal_check_js.go
new file mode 100644
index 0000000..ebdae3e
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_js.go
@@ -0,0 +1,7 @@
+// +build js
+
+package logrus
+
+func isTerminal(fd int) bool {
+        return false
+}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go b/vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go
new file mode 100644
index 0000000..97af92c
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go
@@ -0,0 +1,11 @@
+// +build js nacl plan9
+
+package logrus
+
+import (
+        "io"
+)
+
+func checkIfTerminal(w io.Writer) bool {
+        return false
+}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go b/vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go
new file mode 100644
index 0000000..3293fb3
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go
@@ -0,0 +1,17 @@
+// +build !appengine,!js,!windows,!nacl,!plan9
+
+package logrus
+
+import (
+        "io"
+        "os"
+)
+
+func checkIfTerminal(w io.Writer) bool {
+        switch v := w.(type) {
+        case *os.File:
+                return isTerminal(int(v.Fd()))
+        default:
+                return false
+        }
+}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_solaris.go b/vendor/github.com/sirupsen/logrus/terminal_check_solaris.go
new file mode 100644
index 0000000..f6710b3
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_solaris.go
@@ -0,0 +1,11 @@
+package logrus
+
+import (
+        "golang.org/x/sys/unix"
+)
+
+// IsTerminal returns true if the given file descriptor is a terminal.
+func isTerminal(fd int) bool {
+        _, err := unix.IoctlGetTermio(fd, unix.TCGETA)
+        return err == nil
+}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_unix.go b/vendor/github.com/sirupsen/logrus/terminal_check_unix.go
new file mode 100644
index 0000000..04748b8
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_unix.go
@@ -0,0 +1,13 @@
+// +build linux aix zos
+// +build !js
+
+package logrus
+
+import "golang.org/x/sys/unix"
+
+const ioctlReadTermios = unix.TCGETS
+
+func isTerminal(fd int) bool {
+        _, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
+        return err == nil
+}
diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_windows.go b/vendor/github.com/sirupsen/logrus/terminal_check_windows.go
new file mode 100644
index 0000000..2879eb5
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/terminal_check_windows.go
@@ -0,0 +1,27 @@
+// +build !appengine,!js,windows
+
+package logrus
+
+import (
+        "io"
+        "os"
+
+        "golang.org/x/sys/windows"
+)
+
+func checkIfTerminal(w io.Writer) bool {
+        switch v := w.(type) {
+        case *os.File:
+                handle := windows.Handle(v.Fd())
+                var mode uint32
+                if err := windows.GetConsoleMode(handle, &mode); err != nil {
+                        return false
+                }
+                mode |= windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING
+                if err := windows.SetConsoleMode(handle, mode); err != nil {
+                        return false
+                }
+                return true
+        }
+        return false
+}
diff --git a/vendor/github.com/sirupsen/logrus/text_formatter.go b/vendor/github.com/sirupsen/logrus/text_formatter.go
new file mode 100644
index 0000000..be2c6ef
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/text_formatter.go
@@ -0,0 +1,339 @@
+package logrus
+
+import (
+        "bytes"
+        "fmt"
+        "os"
+        "runtime"
+        "sort"
+        "strconv"
+        "strings"
+        "sync"
+        "time"
+        "unicode/utf8"
+)
+
+const (
+        red    = 31
+        yellow = 33
+        blue   = 36
+        gray   = 37
+)
+
+var baseTimestamp time.Time
+
+func init() {
+        baseTimestamp = time.Now()
+}
+
+// TextFormatter formats logs into text
+type TextFormatter struct {
+        // Set to true to bypass checking for a TTY before outputting colors.
+        ForceColors bool
+
+        // Force disabling colors.
+        DisableColors bool
+
+        // Force quoting of all values
+        ForceQuote bool
+
+        // DisableQuote disables quoting for all values.
+        // DisableQuote will have a lower priority than ForceQuote.
+        // If both of them are set to true, quote will be forced on all values.
+        DisableQuote bool
+
+        // Override coloring based on CLICOLOR and CLICOLOR_FORCE. - https://bixense.com/clicolors/
+        EnvironmentOverrideColors bool
+
+        // Disable timestamp logging. useful when output is redirected to logging
+        // system that already adds timestamps.
+        DisableTimestamp bool
+
+        // Enable logging the full timestamp when a TTY is attached instead of just
+        // the time passed since beginning of execution.
+        FullTimestamp bool
+
+        // TimestampFormat to use for display when a full timestamp is printed.
+        // The format to use is the same than for time.Format or time.Parse from the standard
+        // library.
+        // The standard Library already provides a set of predefined format.
+        TimestampFormat string
+
+        // The fields are sorted by default for a consistent output. For applications
+        // that log extremely frequently and don't use the JSON formatter this may not
+        // be desired.
+        DisableSorting bool
+
+        // The keys sorting function, when uninitialized it uses sort.Strings.
+        SortingFunc func([]string)
+
+        // Disables the truncation of the level text to 4 characters.
+        DisableLevelTruncation bool
+
+        // PadLevelText Adds padding the level text so that all the levels output at the same length
+        // PadLevelText is a superset of the DisableLevelTruncation option
+        PadLevelText bool
+
+        // QuoteEmptyFields will wrap empty fields in quotes if true
+        QuoteEmptyFields bool
+
+        // Whether the logger's out is to a terminal
+        isTerminal bool
+
+        // FieldMap allows users to customize the names of keys for default fields.
+        // As an example:
+        // formatter := &TextFormatter{
+        //     FieldMap: FieldMap{
+        //         FieldKeyTime:  "@timestamp",
+        //         FieldKeyLevel: "@level",
+        //         FieldKeyMsg:   "@message"}}
+        FieldMap FieldMap
+
+        // CallerPrettyfier can be set by the user to modify the content
+        // of the function and file keys in the data when ReportCaller is
+        // activated. If any of the returned value is the empty string the
+        // corresponding key will be removed from fields.
+        CallerPrettyfier func(*runtime.Frame) (function string, file string)
+
+        terminalInitOnce sync.Once
+
+        // The max length of the level text, generated dynamically on init
+        levelTextMaxLength int
+}
+
+func (f *TextFormatter) init(entry *Entry) {
+        if entry.Logger != nil {
+                f.isTerminal = checkIfTerminal(entry.Logger.Out)
+        }
+        // Get the max length of the level text
+        for _, level := range AllLevels {
+                levelTextLength := utf8.RuneCount([]byte(level.String()))
+                if levelTextLength > f.levelTextMaxLength {
+                        f.levelTextMaxLength = levelTextLength
+                }
+        }
+}
+
+func (f *TextFormatter) isColored() bool {
+        isColored := f.ForceColors || (f.isTerminal && (runtime.GOOS != "windows"))
+
+        if f.EnvironmentOverrideColors {
+                switch force, ok := os.LookupEnv("CLICOLOR_FORCE"); {
+                case ok && force != "0":
+                        isColored = true
+                case ok && force == "0", os.Getenv("CLICOLOR") == "0":
+                        isColored = false
+                }
+        }
+
+        return isColored && !f.DisableColors
+}
+
+// Format renders a single log entry
+func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
+        data := make(Fields)
+        for k, v := range entry.Data {
+                data[k] = v
+        }
+        prefixFieldClashes(data, f.FieldMap, entry.HasCaller())
+        keys := make([]string, 0, len(data))
+        for k := range data {
+                keys = append(keys, k)
+        }
+
+        var funcVal, fileVal string
+
+        fixedKeys := make([]string, 0, 4+len(data))
+        if !f.DisableTimestamp {
+                fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyTime))
+        }
+        fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLevel))
+        if entry.Message != "" {
+                fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyMsg))
+        }
+        if entry.err != "" {
+                fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLogrusError))
+        }
+        if entry.HasCaller() {
+                if f.CallerPrettyfier != nil {
+                        funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
+                } else {
+                        funcVal = entry.Caller.Function
+                        fileVal = fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
+                }
+
+                if funcVal != "" {
+                        fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFunc))
+                }
+                if fileVal != "" {
+                        fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFile))
+                }
+        }
+
+        if !f.DisableSorting {
+                if f.SortingFunc == nil {
+                        sort.Strings(keys)
+                        fixedKeys = append(fixedKeys, keys...)
+                } else {
+                        if !f.isColored() {
+                                fixedKeys = append(fixedKeys, keys...)
+                                f.SortingFunc(fixedKeys)
+                        } else {
+                                f.SortingFunc(keys)
+                        }
+                }
+        } else {
+                fixedKeys = append(fixedKeys, keys...)
+        }
+
+        var b *bytes.Buffer
+        if entry.Buffer != nil {
+                b = entry.Buffer
+        } else {
+                b = &bytes.Buffer{}
+        }
+
+        f.terminalInitOnce.Do(func() { f.init(entry) })
+
+        timestampFormat := f.TimestampFormat
+        if timestampFormat == "" {
+                timestampFormat = defaultTimestampFormat
+        }
+        if f.isColored() {
+                f.printColored(b, entry, keys, data, timestampFormat)
+        } else {
+
+                for _, key := range fixedKeys {
+                        var value interface{}
+                        switch {
+                        case key == f.FieldMap.resolve(FieldKeyTime):
+                                value = entry.Time.Format(timestampFormat)
+                        case key == f.FieldMap.resolve(FieldKeyLevel):
+                                value = entry.Level.String()
+                        case key == f.FieldMap.resolve(FieldKeyMsg):
+                                value = entry.Message
+                        case key == f.FieldMap.resolve(FieldKeyLogrusError):
+                                value = entry.err
+                        case key == f.FieldMap.resolve(FieldKeyFunc) && entry.HasCaller():
+                                value = funcVal
+                        case key == f.FieldMap.resolve(FieldKeyFile) && entry.HasCaller():
+                                value = fileVal
+                        default:
+                                value = data[key]
+                        }
+                        f.appendKeyValue(b, key, value)
+                }
+        }
+
+        b.WriteByte('\n')
+        return b.Bytes(), nil
+}
+
+func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, data Fields, timestampFormat string) {
+        var levelColor int
+        switch entry.Level {
+        case DebugLevel, TraceLevel:
+                levelColor = gray
+        case WarnLevel:
+                levelColor = yellow
+        case ErrorLevel, FatalLevel, PanicLevel:
+                levelColor = red
+        case InfoLevel:
+                levelColor = blue
+        default:
+                levelColor = blue
+        }
+
+        levelText := strings.ToUpper(entry.Level.String())
+        if !f.DisableLevelTruncation && !f.PadLevelText {
+                levelText = levelText[0:4]
+        }
+        if f.PadLevelText {
+                // Generates the format string used in the next line, for example "%-6s" or "%-7s".
+                // Based on the max level text length.
+                formatString := "%-" + strconv.Itoa(f.levelTextMaxLength) + "s"
+                // Formats the level text by appending spaces up to the max length, for example:
+                //      - "INFO   "
+                //      - "WARNING"
+                levelText = fmt.Sprintf(formatString, levelText)
+        }
+
+        // Remove a single newline if it already exists in the message to keep
+        // the behavior of logrus text_formatter the same as the stdlib log package
+        entry.Message = strings.TrimSuffix(entry.Message, "\n")
+
+        caller := ""
+        if entry.HasCaller() {
+                funcVal := fmt.Sprintf("%s()", entry.Caller.Function)
+                fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
+
+                if f.CallerPrettyfier != nil {
+                        funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
+                }
+
+                if fileVal == "" {
+                        caller = funcVal
+                } else if funcVal == "" {
+                        caller = fileVal
+                } else {
+                        caller = fileVal + " " + funcVal
+                }
+        }
+
+        switch {
+        case f.DisableTimestamp:
+                fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m%s %-44s ", levelColor, levelText, caller, entry.Message)
+        case !f.FullTimestamp:
+                fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d]%s %-44s ", levelColor, levelText, int(entry.Time.Sub(baseTimestamp)/time.Second), caller, entry.Message)
+        default:
+                fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s]%s %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), caller, entry.Message)
+        }
+        for _, k := range keys {
+                v := data[k]
+                fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=", levelColor, k)
+                f.appendValue(b, v)
+        }
+}
+
+func (f *TextFormatter) needsQuoting(text string) bool {
+        if f.ForceQuote {
+                return true
+        }
+        if f.QuoteEmptyFields && len(text) == 0 {
+                return true
+        }
+        if f.DisableQuote {
+                return false
+        }
+        for _, ch := range text {
+                if !((ch >= 'a' && ch <= 'z') ||
+                        (ch >= 'A' && ch <= 'Z') ||
+                        (ch >= '0' && ch <= '9') ||
+                        ch == '-' || ch == '.' || ch == '_' || ch == '/' || ch == '@' || ch == '^' || ch == '+') {
+                        return true
+                }
+        }
+        return false
+}
+
+func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) {
+        if b.Len() > 0 {
+                b.WriteByte(' ')
+        }
+        b.WriteString(key)
+        b.WriteByte('=')
+        f.appendValue(b, value)
+}
+
+func (f *TextFormatter) appendValue(b *bytes.Buffer, value interface{}) {
+        stringVal, ok := value.(string)
+        if !ok {
+                stringVal = fmt.Sprint(value)
+        }
+
+        if !f.needsQuoting(stringVal) {
+                b.WriteString(stringVal)
+        } else {
+                b.WriteString(fmt.Sprintf("%q", stringVal))
+        }
+}
diff --git a/vendor/github.com/sirupsen/logrus/writer.go b/vendor/github.com/sirupsen/logrus/writer.go
new file mode 100644
index 0000000..074fd4b
--- /dev/null
+++ b/vendor/github.com/sirupsen/logrus/writer.go
@@ -0,0 +1,102 @@
+package logrus
+
+import (
+        "bufio"
+        "io"
+        "runtime"
+        "strings"
+)
+
+// Writer at INFO level. See WriterLevel for details.
+func (logger *Logger) Writer() *io.PipeWriter {
+        return logger.WriterLevel(InfoLevel)
+}
+
+// WriterLevel returns an io.Writer that can be used to write arbitrary text to
+// the logger at the given log level. Each line written to the writer will be
+// printed in the usual way using formatters and hooks. The writer is part of an
+// io.Pipe and it is the callers responsibility to close the writer when done.
+// This can be used to override the standard library logger easily.
+func (logger *Logger) WriterLevel(level Level) *io.PipeWriter {
+        return NewEntry(logger).WriterLevel(level)
+}
+
+// Writer returns an io.Writer that writes to the logger at the info log level
+func (entry *Entry) Writer() *io.PipeWriter {
+        return entry.WriterLevel(InfoLevel)
+}
+
+// WriterLevel returns an io.Writer that writes to the logger at the given log level
+func (entry *Entry) WriterLevel(level Level) *io.PipeWriter {
+        reader, writer := io.Pipe()
+
+        var printFunc func(args ...interface{})
+
+        // Determine which log function to use based on the specified log level
+        switch level {
+        case TraceLevel:
+                printFunc = entry.Trace
+        case DebugLevel:
+                printFunc = entry.Debug
+        case InfoLevel:
+                printFunc = entry.Info
+        case WarnLevel:
+                printFunc = entry.Warn
+        case ErrorLevel:
+                printFunc = entry.Error
+        case FatalLevel:
+                printFunc = entry.Fatal
+        case PanicLevel:
+                printFunc = entry.Panic
+        default:
+                printFunc = entry.Print
+        }
+
+        // Start a new goroutine to scan the input and write it to the logger using the specified print function.
+        // It splits the input into chunks of up to 64KB to avoid buffer overflows.
+        go entry.writerScanner(reader, printFunc)
+
+        // Set a finalizer function to close the writer when it is garbage collected
+        runtime.SetFinalizer(writer, writerFinalizer)
+
+        return writer
+}
+
+// writerScanner scans the input from the reader and writes it to the logger
+func (entry *Entry) writerScanner(reader *io.PipeReader, printFunc func(args ...interface{})) {
+        scanner := bufio.NewScanner(reader)
+
+        // Set the buffer size to the maximum token size to avoid buffer overflows
+        scanner.Buffer(make([]byte, bufio.MaxScanTokenSize), bufio.MaxScanTokenSize)
+
+        // Define a split function to split the input into chunks of up to 64KB
+        chunkSize := bufio.MaxScanTokenSize // 64KB
+        splitFunc := func(data []byte, atEOF bool) (int, []byte, error) {
+                if len(data) >= chunkSize {
+                        return chunkSize, data[:chunkSize], nil
+                }
+
+                return bufio.ScanLines(data, atEOF)
+        }
+
+        // Use the custom split function to split the input
+        scanner.Split(splitFunc)
+
+        // Scan the input and write it to the logger using the specified print function
+        for scanner.Scan() {
+                printFunc(strings.TrimRight(scanner.Text(), "\r\n"))
+        }
+
+        // If there was an error while scanning the input, log an error
+        if err := scanner.Err(); err != nil {
+                entry.Errorf("Error while reading from Writer: %s", err)
+        }
+
+        // Close the reader when we are done
+        reader.Close()
+}
+
+// WriterFinalizer is a finalizer function that closes then given writer when it is garbage collected
+func writerFinalizer(writer *io.PipeWriter) {
+        writer.Close()
+}