~tsileo/blobstash

b3026eb919923e0e7f164c2d8329f65c63265a10 — Thomas Sileo 4 months ago 215df84
vendor: update deps
46 files changed, 1385 insertions(+), 520 deletions(-)

M go.mod
M go.sum
M vendor/github.com/alecthomas/chroma/formatters/html/html.go
M vendor/github.com/alecthomas/chroma/go.mod
M vendor/github.com/alecthomas/chroma/go.sum
A vendor/github.com/alecthomas/chroma/lexers/g/gherkin.go
M vendor/github.com/alecthomas/chroma/lexers/internal/api.go
M vendor/github.com/alecthomas/chroma/lexers/j/jsx.go
A vendor/github.com/alecthomas/chroma/lexers/r/reasonml.go
M vendor/github.com/alecthomas/chroma/lexers/t/typescript.go
A vendor/github.com/alecthomas/chroma/lexers/y/yang.go
M vendor/github.com/aws/aws-sdk-go/aws/endpoints/defaults.go
M vendor/github.com/aws/aws-sdk-go/aws/version.go
M vendor/github.com/klauspost/reedsolomon/.travis.yml
M vendor/github.com/klauspost/reedsolomon/README.md
M vendor/github.com/klauspost/reedsolomon/galoisAvx512_amd64.go
M vendor/github.com/klauspost/reedsolomon/galoisAvx512_amd64.s
M vendor/github.com/klauspost/reedsolomon/galois_amd64.go
M vendor/github.com/klauspost/reedsolomon/galois_amd64.s
M vendor/github.com/klauspost/reedsolomon/galois_arm64.go
M vendor/github.com/klauspost/reedsolomon/galois_noasm.go
M vendor/github.com/klauspost/reedsolomon/galois_ppc64le.go
M vendor/github.com/klauspost/reedsolomon/galois_ppc64le.s
M vendor/github.com/klauspost/reedsolomon/options.go
M vendor/github.com/klauspost/reedsolomon/reedsolomon.go
M vendor/github.com/klauspost/reedsolomon/streaming.go
M vendor/golang.org/x/sys/unix/syscall_darwin.go
M vendor/golang.org/x/sys/unix/syscall_darwin_386.go
M vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go
M vendor/golang.org/x/sys/unix/syscall_darwin_arm.go
M vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go
M vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_11.go
M vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go
M vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_11.go
M vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
M vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_11.go
M vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go
M vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_11.go
M vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
M vendor/golang.org/x/sys/unix/zsysctl_openbsd_386.go
M vendor/golang.org/x/sys/unix/zsysctl_openbsd_amd64.go
M vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm.go
M vendor/golang.org/x/sys/windows/dll_windows.go
M vendor/golang.org/x/sys/windows/syscall_windows.go
M vendor/gopkg.in/yaml.v2/apic.go
M vendor/modules.txt
M go.mod => go.mod +7 -7
@@ 6,8 6,8 @@ require (
	a4.io/gluarequire2 v0.0.0-20200222094423-7528d5a10bc1
	a4.io/go/indieauth v1.0.3
	a4.io/ssse v0.0.0-20181202155639-1949828a8689
	github.com/alecthomas/chroma v0.7.2 // indirect
	github.com/aws/aws-sdk-go v1.30.23
	github.com/alecthomas/chroma v0.7.3 // indirect
	github.com/aws/aws-sdk-go v1.30.27
	github.com/blevesearch/segment v0.9.0
	github.com/carbocation/interpose v0.0.0-20161206215253-723534742ba3
	github.com/dave/jennifer v1.4.0


@@ 22,7 22,7 @@ require (
	github.com/gorilla/sessions v1.2.0
	github.com/hashicorp/golang-lru v0.5.4
	github.com/inconshreveable/log15 v0.0.0-20200109203555-b30bc20e4fd1
	github.com/klauspost/reedsolomon v1.9.6 // indirect
	github.com/klauspost/reedsolomon v1.9.7 // indirect
	github.com/konsorten/go-windows-terminal-sequences v1.0.3 // indirect
	github.com/mvdan/xurls v1.1.0 // indirect
	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646


@@ 37,13 37,13 @@ require (
	github.com/yuin/goldmark v1.1.30
	github.com/yuin/gopher-lua v0.0.0-20191220021717-ab39c6098bdb
	github.com/zpatrick/rbac v0.0.0-20180829190353-d2c4f050cf28
	golang.org/x/crypto v0.0.0-20200429183012-4b2356b1ed79
	golang.org/x/net v0.0.0-20200506145744-7e3656a0809f // indirect
	golang.org/x/sys v0.0.0-20200501145240-bc7a7d42d5c3 // indirect
	golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37
	golang.org/x/net v0.0.0-20200513185701-a91f0712d120 // indirect
	golang.org/x/sys v0.0.0-20200513112337-417ce2331b5c // indirect
	google.golang.org/appengine v1.6.6 // indirect
	gopkg.in/inconshreveable/log15.v2 v2.0.0-20200109203555-b30bc20e4fd1
	gopkg.in/src-d/go-git.v4 v4.13.1
	gopkg.in/yaml.v2 v2.2.8
	gopkg.in/yaml.v2 v2.3.0
	willnorris.com/go/microformats v1.0.0
)


M go.sum => go.sum +19 -0
@@ 60,10 60,13 @@ github.com/alecthomas/chroma v0.7.2-0.20200305040604-4f3623dce67a h1:3v1NrYWWqp2
github.com/alecthomas/chroma v0.7.2-0.20200305040604-4f3623dce67a/go.mod h1:fv5SzZPFJbwp2NXJWpFIX7DZS4HgV1K4ew4Pc2OZD9s=
github.com/alecthomas/chroma v0.7.2 h1:B76NU/zbQYIUhUowbi4fmvREmDUJLsUzKWTZmQd3ABY=
github.com/alecthomas/chroma v0.7.2/go.mod h1:fv5SzZPFJbwp2NXJWpFIX7DZS4HgV1K4ew4Pc2OZD9s=
github.com/alecthomas/chroma v0.7.3 h1:NfdAERMy+esYQs8OXk0I868/qDxxCEo7FMz1WIqMAeI=
github.com/alecthomas/chroma v0.7.3/go.mod h1:sko8vR34/90zvl5QdcUdvzL3J8NKjAUx9va9jPuFNoM=
github.com/alecthomas/colour v0.0.0-20160524082231-60882d9e2721 h1:JHZL0hZKJ1VENNfmXvHbgYlbUOvpzYzvy2aZU5gXVeo=
github.com/alecthomas/colour v0.0.0-20160524082231-60882d9e2721/go.mod h1:QO9JBoKquHd+jz9nshCh40fOfO+JzsoXy8qTHF68zU0=
github.com/alecthomas/kong v0.1.17-0.20190424132513-439c674f7ae0/go.mod h1:+inYUSluD+p4L8KdviBSgzcqEjUQOfC5fQDRFuc36lI=
github.com/alecthomas/kong v0.2.1-0.20190708041108-0548c6b1afae/go.mod h1:+inYUSluD+p4L8KdviBSgzcqEjUQOfC5fQDRFuc36lI=
github.com/alecthomas/kong v0.2.4/go.mod h1:kQOmtJgV+Lb4aj+I2LEn40cbtawdWJ9Y8QLq+lElKxE=
github.com/alecthomas/kong-hcl v0.1.8-0.20190615233001-b21fea9723c8/go.mod h1:MRgZdU3vrFd05IQ89AxUZ0aYdF39BYoNFa324SodPCA=
github.com/alecthomas/repr v0.0.0-20180818092828-117648cd9897 h1:p9Sln00KOTlrYkxI1zYWl1QLnEqAqEARBEYa8FQnQcY=
github.com/alecthomas/repr v0.0.0-20180818092828-117648cd9897/go.mod h1:xTS7Pm1pD1mvyM075QCDSRqH6qRLXylzS24ZTpRiSzQ=


@@ 93,6 96,10 @@ github.com/aws/aws-sdk-go v1.30.18 h1:aRdRUA5V7RMvScHBBg+4elOrSM+5oHsYzUngLuSK6l
github.com/aws/aws-sdk-go v1.30.18/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
github.com/aws/aws-sdk-go v1.30.23 h1:1Npeg2q6hicbrHoFu6MoeqZdcQf8187BI0VwKxEfLAY=
github.com/aws/aws-sdk-go v1.30.23/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
github.com/aws/aws-sdk-go v1.30.24 h1:y3JPD51VuEmVqN3BEDVm4amGpDma2cKJcDPuAU1OR58=
github.com/aws/aws-sdk-go v1.30.24/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
github.com/aws/aws-sdk-go v1.30.27 h1:9gPjZWVDSoQrBO2AvqrWObS6KAZByfEJxQoCYo4ZfK0=
github.com/aws/aws-sdk-go v1.30.27/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
github.com/blevesearch/segment v0.0.0-20160915185041-762005e7a34f h1:kqbi9lqXLLs+zfWlgo1PIiRQ86n33K1JKotjj4rSYOg=
github.com/blevesearch/segment v0.0.0-20160915185041-762005e7a34f/go.mod h1:IInt5XRvpiGE09KOk9mmCMLjHhydIhNPKPPFLFBB7L8=
github.com/blevesearch/segment v0.9.0 h1:5lG7yBCx98or7gK2cHMKPukPZ/31Kag7nONpoBt22Ac=


@@ 279,6 286,8 @@ github.com/klauspost/reedsolomon v1.9.4 h1:FB9jDBGqUNyhUg4Gszz384ulFqVSc61Pdap+H
github.com/klauspost/reedsolomon v1.9.4/go.mod h1:CwCi+NUr9pqSVktrkN+Ondf06rkhYZ/pcNv7fu+8Un4=
github.com/klauspost/reedsolomon v1.9.6 h1:sXZANEgYACIcmbk90z6MV4XL29d0Lm6AFleWRPZJxi8=
github.com/klauspost/reedsolomon v1.9.6/go.mod h1:+8WD025Xpby8/kG5h/HDPIFhiiuGEtZOKw+5Y4drAD8=
github.com/klauspost/reedsolomon v1.9.7 h1:+azeqnT4iNG9UEcWC+7utJ4xXQ9S8pSlkZor0DOArEQ=
github.com/klauspost/reedsolomon v1.9.7/go.mod h1:+8WD025Xpby8/kG5h/HDPIFhiiuGEtZOKw+5Y4drAD8=
github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/konsorten/go-windows-terminal-sequences v1.0.2 h1:DB17ag19krx9CFsz4o3enTrPXyIXCl+2iCXH/aMAp9s=


@@ 488,6 497,8 @@ golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5 h1:Q7tZBpemrlsc2I7IyODzht
golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20200429183012-4b2356b1ed79 h1:IaQbIIB2X/Mp/DKctl6ROxz1KyMlKp4uyvL6+kQ7C88=
golang.org/x/crypto v0.0.0-20200429183012-4b2356b1ed79/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37 h1:cg5LA/zNPRzIXIWSCxQW10Rvpy94aQh3LT/ShoCpkHw=
golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181213202711-891ebc4b82d6 h1:gT0Y6H7hbVPUtvtk0YGxMXPgN+p8fYlqWkgJeUCZcaQ=


@@ 520,6 531,8 @@ golang.org/x/net v0.0.0-20200425230154-ff2c4b7c35a0 h1:Jcxah/M+oLZ/R4/z5RzfPzGbP
golang.org/x/net v0.0.0-20200425230154-ff2c4b7c35a0/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200506145744-7e3656a0809f h1:QBjCr1Fz5kw158VqdE9JfI9cJnl/ymnJWAdMuinqL7Y=
golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200513185701-a91f0712d120 h1:EZ3cVSzKOlJxAd8e8YAJ7no8nNypTxexh/YE/xW3ZEY=
golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ=
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=


@@ 569,6 582,10 @@ golang.org/x/sys v0.0.0-20200430082407-1f5687305801 h1:Jp2/1+ZY++XrlALjnberpN8Qk
golang.org/x/sys v0.0.0-20200430082407-1f5687305801/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200501145240-bc7a7d42d5c3 h1:5B6i6EAiSYyejWfvc5Rc9BbI3rzIsrrXfAQBWnYfn+w=
golang.org/x/sys v0.0.0-20200501145240-bc7a7d42d5c3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200509044756-6aff5f38e54f h1:mOhmO9WsBaJCNmaZHPtHs9wOcdqdKCjF6OPJlmDM3KI=
golang.org/x/sys v0.0.0-20200509044756-6aff5f38e54f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200513112337-417ce2331b5c h1:kISX68E8gSkNYAFRFiDU8rl5RIn1sJYKYb/r2vMLDrU=
golang.org/x/sys v0.0.0-20200513112337-417ce2331b5c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=


@@ 637,6 654,8 @@ gopkg.in/yaml.v2 v2.2.5 h1:ymVxjfMaHvXD8RqPRmzHHsB3VvucivSkIAvJFDI5O3c=
gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
mvdan.cc/xurls v1.1.0 h1:kj0j2lonKseISJCiq1Tfk+iTv65dDGCl0rTbanXJGGc=
mvdan.cc/xurls v1.1.0/go.mod h1:TNWuhvo+IqbUCmtUIb/3LJSQdrzel8loVpgFm0HikbI=
willnorris.com/go/microformats v1.0.0 h1:II6uDIJBPp6RpJQqRWm+6IN9lI00mN/jQAC5OHuF4HA=

M vendor/github.com/alecthomas/chroma/formatters/html/html.go => vendor/github.com/alecthomas/chroma/formatters/html/html.go +5 -1
@@ 366,8 366,12 @@ func (f *Formatter) WriteCSS(w io.Writer, style *chroma.Style) error {
		if tt == chroma.Background {
			continue
		}
		class := f.class(tt)
		if class == "" {
			continue
		}
		styles := css[tt]
		if _, err := fmt.Fprintf(w, "/* %s */ .%schroma .%s { %s }\n", tt, f.prefix, f.class(tt), styles); err != nil {
		if _, err := fmt.Fprintf(w, "/* %s */ .%schroma .%s { %s }\n", tt, f.prefix, class, styles); err != nil {
			return err
		}
	}

M vendor/github.com/alecthomas/chroma/go.mod => vendor/github.com/alecthomas/chroma/go.mod +6 -5
@@ 5,13 5,14 @@ go 1.13
require (
	github.com/alecthomas/assert v0.0.0-20170929043011-405dbfeb8e38
	github.com/alecthomas/colour v0.0.0-20160524082231-60882d9e2721 // indirect
	github.com/alecthomas/kong v0.2.1-0.20190708041108-0548c6b1afae
	github.com/alecthomas/kong v0.2.4
	github.com/alecthomas/repr v0.0.0-20180818092828-117648cd9897 // indirect
	github.com/danwakefield/fnmatch v0.0.0-20160403171240-cbb64ac3d964
	github.com/dlclark/regexp2 v1.1.6
	github.com/mattn/go-colorable v0.0.9
	github.com/mattn/go-isatty v0.0.4
	github.com/dlclark/regexp2 v1.2.0
	github.com/mattn/go-colorable v0.1.6
	github.com/mattn/go-isatty v0.0.12
	github.com/pkg/errors v0.9.1 // indirect
	github.com/sergi/go-diff v1.0.0 // indirect
	github.com/stretchr/testify v1.3.0 // indirect
	golang.org/x/sys v0.0.0-20181128092732-4ed8d59d0b35 // indirect
	golang.org/x/sys v0.0.0-20200413165638-669c56c373c4 // indirect
)

M vendor/github.com/alecthomas/chroma/go.sum => vendor/github.com/alecthomas/chroma/go.sum +14 -11
@@ 2,8 2,8 @@ github.com/alecthomas/assert v0.0.0-20170929043011-405dbfeb8e38 h1:smF2tmSOzy2Mm
github.com/alecthomas/assert v0.0.0-20170929043011-405dbfeb8e38/go.mod h1:r7bzyVFMNntcxPZXK3/+KdruV1H5KSlyVY0gc+NgInI=
github.com/alecthomas/colour v0.0.0-20160524082231-60882d9e2721 h1:JHZL0hZKJ1VENNfmXvHbgYlbUOvpzYzvy2aZU5gXVeo=
github.com/alecthomas/colour v0.0.0-20160524082231-60882d9e2721/go.mod h1:QO9JBoKquHd+jz9nshCh40fOfO+JzsoXy8qTHF68zU0=
github.com/alecthomas/kong v0.2.1-0.20190708041108-0548c6b1afae h1:C4Q9m+oXOxcSWwYk9XzzafY2xAVAaeubZbUHJkw3PlY=
github.com/alecthomas/kong v0.2.1-0.20190708041108-0548c6b1afae/go.mod h1:+inYUSluD+p4L8KdviBSgzcqEjUQOfC5fQDRFuc36lI=
github.com/alecthomas/kong v0.2.4 h1:Y0ZBCHAvHhTHw7FFJ2FzCAAG4pkbTgA45nc7BpMhDNk=
github.com/alecthomas/kong v0.2.4/go.mod h1:kQOmtJgV+Lb4aj+I2LEn40cbtawdWJ9Y8QLq+lElKxE=
github.com/alecthomas/repr v0.0.0-20180818092828-117648cd9897 h1:p9Sln00KOTlrYkxI1zYWl1QLnEqAqEARBEYa8FQnQcY=
github.com/alecthomas/repr v0.0.0-20180818092828-117648cd9897/go.mod h1:xTS7Pm1pD1mvyM075QCDSRqH6qRLXylzS24ZTpRiSzQ=
github.com/danwakefield/fnmatch v0.0.0-20160403171240-cbb64ac3d964 h1:y5HC9v93H5EPKqaS1UYVg1uYah5Xf51mBfIoWehClUQ=


@@ 11,15 11,16 @@ github.com/danwakefield/fnmatch v0.0.0-20160403171240-cbb64ac3d964/go.mod h1:Xd9
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dlclark/regexp2 v1.1.6 h1:CqB4MjHw0MFCDj+PHHjiESmHX+N7t0tJzKvC6M97BRg=
github.com/dlclark/regexp2 v1.1.6/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4=
github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
github.com/mattn/go-isatty v0.0.4 h1:bnP0vzxcAdeI1zdubAl5PjU6zsERjGZb7raWodagDYs=
github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
github.com/dlclark/regexp2 v1.2.0 h1:8sAhBGEM0dRWogWqWyQeIJnxjWO6oIjl8FKqREDsGfk=
github.com/dlclark/regexp2 v1.2.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
github.com/mattn/go-colorable v0.1.6 h1:6Su7aK7lXmJ/U79bYtBjLNaha4Fs1Rg9plHpcH+vvnE=
github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=


@@ 29,5 30,7 @@ github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
golang.org/x/sys v0.0.0-20181128092732-4ed8d59d0b35 h1:YAFjXN64LMvktoUZH9zgY4lGc/msGN7HQfoSuKCgaDU=
golang.org/x/sys v0.0.0-20181128092732-4ed8d59d0b35/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200413165638-669c56c373c4 h1:opSr2sbRXk5X5/givKrrKj9HXxFpW2sdCiP8MJSKLQY=
golang.org/x/sys v0.0.0-20200413165638-669c56c373c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

A vendor/github.com/alecthomas/chroma/lexers/g/gherkin.go => vendor/github.com/alecthomas/chroma/lexers/g/gherkin.go +118 -0
@@ 0,0 1,118 @@
package g

import (
	. "github.com/alecthomas/chroma" // nolint
	"github.com/alecthomas/chroma/lexers/internal"
)

var stepKeywords = `^(\s*)(하지만|조건|먼저|만일|만약|단|그리고|그러면|那麼|那么|而且|當|当|前提|假設|假设|假如|假定|但是|但し|並且|并且|同時|同时|もし|ならば|ただし|しかし|かつ|و |متى |لكن |عندما |ثم |بفرض |اذاً |כאשר |וגם |בהינתן |אזי |אז |אבל |Якщо |Унда |То |Припустимо, що |Припустимо |Онда |Но |Нехай |Лекин |Когато |Када |Кад |К тому же |И |Задато |Задати |Задате |Если |Допустим |Дадено |Ва |Бирок |Аммо |Али |Але |Агар |А |І |Și |És |Zatati |Zakładając |Zadato |Zadate |Zadano |Zadani |Zadan |Youse know when youse got |Youse know like when |Yna |Ya know how |Ya gotta |Y |Wun |Wtedy |When y'all |When |Wenn |WEN |Và |Ve |Und |Un |Thì |Then y'all |Then |Tapi |Tak |Tada |Tad |Så |Stel |Soit |Siis |Si |Sed |Se |Quando |Quand |Quan |Pryd |Pokud |Pokiaľ |Però |Pero |Pak |Oraz |Onda |Ond |Oletetaan |Og |Och |O zaman |Når |När |Niin |Nhưng |N |Mutta |Men |Mas |Maka |Majd |Mais |Maar |Ma |Lorsque |Lorsqu'|Kun |Kuid |Kui |Khi |Keď |Ketika |Když |Kaj |Kai |Kada |Kad |Jeżeli |Ja |Ir |I CAN HAZ |I |Ha |Givun |Givet |Given y'all |Given |Gitt |Gegeven |Gegeben sei |Fakat |Eğer ki |Etant donné |Et |Então |Entonces |Entao |En |Eeldades |E |Duota |Dun |Donitaĵo |Donat |Donada |Do |Diyelim ki |Dengan |Den youse gotta |De |Dato |Dar |Dann |Dan |Dado |Dacă |Daca |DEN |Când |Cuando |Cho |Cept |Cand |Cal |But y'all |But |Buh |Biết |Bet |BUT |Atès |Atunci |Atesa |Anrhegedig a |Angenommen |And y'all |And |An |Ama |Als |Alors |Allora |Ali |Aleshores |Ale |Akkor |Aber |AN |A také |A |\* )`

var featureKeywords = `^(기능|機能|功能|フィーチャ|خاصية|תכונה|Функціонал|Функционалност|Функционал|Фича|Особина|Могућност|Özellik|Właściwość|Tính năng|Trajto|Savybė|Požiadavka|Požadavek|Osobina|Ominaisuus|Omadus|OH HAI|Mogućnost|Mogucnost|Jellemző|Fīča|Funzionalità|Funktionalität|Funkcionalnost|Funkcionalitāte|Funcționalitate|Functionaliteit|Functionalitate|Funcionalitat|Funcionalidade|Fonctionnalité|Fitur|Feature|Egenskap|Egenskab|Crikey|Característica|Arwedd)(:)(.*)$`

var featureElementKeywords = `^(\s*)(시나리오 개요|시나리오|배경|背景|場景大綱|場景|场景大纲|场景|劇本大綱|劇本|剧本大纲|剧本|テンプレ|シナリオテンプレート|シナリオテンプレ|シナリオアウトライン|シナリオ|سيناريو مخطط|سيناريو|الخلفية|תרחיש|תבנית תרחיש|רקע|Тарих|Сценарій|Сценарио|Сценарий структураси|Сценарий|Структура сценарію|Структура сценарија|Структура сценария|Скица|Рамка на сценарий|Пример|Предыстория|Предистория|Позадина|Передумова|Основа|Концепт|Контекст|Założenia|Wharrimean is|Tình huống|The thing of it is|Tausta|Taust|Tapausaihio|Tapaus|Szenariogrundriss|Szenario|Szablon scenariusza|Stsenaarium|Struktura scenarija|Skica|Skenario konsep|Skenario|Situācija|Senaryo taslağı|Senaryo|Scénář|Scénario|Schema dello scenario|Scenārijs pēc parauga|Scenārijs|Scenár|Scenaro|Scenariusz|Scenariul de şablon|Scenariul de sablon|Scenariu|Scenario Outline|Scenario Amlinellol|Scenario|Scenarijus|Scenarijaus šablonas|Scenarij|Scenarie|Rerefons|Raamstsenaarium|Primer|Pozadí|Pozadina|Pozadie|Plan du scénario|Plan du Scénario|Osnova scénáře|Osnova|Náčrt Scénáře|Náčrt Scenáru|Mate|MISHUN SRSLY|MISHUN|Kịch bản|Konturo de la scenaro|Kontext|Konteksts|Kontekstas|Kontekst|Koncept|Khung tình huống|Khung kịch bản|Háttér|Grundlage|Geçmiş|Forgatókönyv vázlat|Forgatókönyv|Fono|Esquema do Cenário|Esquema do Cenario|Esquema del escenario|Esquema de l'escenari|Escenario|Escenari|Dis is what went down|Dasar|Contexto|Contexte|Contesto|Condiţii|Conditii|Cenário|Cenario|Cefndir|Bối cảnh|Blokes|Bakgrunn|Bakgrund|Baggrund|Background|B4|Antecedents|Antecedentes|All y'all|Achtergrond|Abstrakt Scenario|Abstract Scenario)(:)(.*)$`

var examplesKeywords = `^(\s*)(예|例子|例|サンプル|امثلة|דוגמאות|Сценарији|Примери|Приклади|Мисоллар|Значения|Örnekler|Voorbeelden|Variantai|Tapaukset|Scenarios|Scenariji|Scenarijai|Příklady|Példák|Príklady|Przykłady|Primjeri|Primeri|Piemēri|Pavyzdžiai|Paraugs|Juhtumid|Exemplos|Exemples|Exemplele|Exempel|Examples|Esempi|Enghreifftiau|Ekzemploj|Eksempler|Ejemplos|EXAMPLZ|Dữ liệu|Contoh|Cobber|Beispiele)(:)(.*)$`

// Gherkin lexer.
var Gherkin = internal.Register(MustNewLexer(
	&Config{
		Name:      "Gherkin",
		Aliases:   []string{"cucumber", "Cucumber", "gherkin", "Gherkin"},
		Filenames: []string{"*.feature", "*.FEATURE"},
		MimeTypes: []string{"text/x-gherkin"},
	},
	Rules{
		"comments": {
			{`\s*#.*$`, Comment, nil},
		},
		"featureElements": {
			{stepKeywords, Keyword, Push("stepContentStack")},
			Include("comments"),
			{`(\s|.)`, NameFunction, nil},
		},
		"featureElementsOnStack": {
			{stepKeywords, Keyword, Pop(2)},
			Include("comments"),
			{`(\s|.)`, NameFunction, nil},
		},
		"examplesTable": {
			{`\s+\|`, Keyword, Push("examplesTableHeader")},
			Include("comments"),
			{`(\s|.)`, NameFunction, nil},
		},
		"examplesTableHeader": {
			{`\s+\|\s*$`, Keyword, Pop(2)},
			Include("comments"),
			{`\\\|`, NameVariable, nil},
			{`\s*\|`, Keyword, nil},
			{`[^|]`, NameVariable, nil},
		},
		"scenarioSectionsOnStack": {
			{featureElementKeywords, ByGroups(NameFunction, Keyword, Keyword, NameFunction), Push("featureElementsOnStack")},
		},
		"narrative": {
			Include("scenarioSectionsOnStack"),
			{`(\s|.)`, NameFunction, nil},
		},
		"tableVars": {
			{`(<[^>]+>)`, NameVariable, nil},
		},
		"numbers": {
			{`(\d+\.?\d*|\d*\.\d+)([eE][+-]?[0-9]+)?`, LiteralString, nil},
		},
		"string": {
			Include("tableVars"),
			{`(\s|.)`, LiteralString, nil},
		},
		"pyString": {
			{`"""`, Keyword, Pop(1)},
			Include("string"),
		},
		"stepContentRoot": {
			{`$`, Keyword, Pop(1)},
			Include("stepContent"),
		},
		"stepContentStack": {
			{`$`, Keyword, Pop(2)},
			Include("stepContent"),
		},
		"stepContent": {
			{`"`, NameFunction, Push("doubleString")},
			Include("tableVars"),
			Include("numbers"),
			Include("comments"),
			{`(\s|.)`, NameFunction, nil},
		},
		"tableContent": {
			{`\s+\|\s*$`, Keyword, Pop(1)},
			Include("comments"),
			{`\\\|`, LiteralString, nil},
			{`\s*\|`, Keyword, nil},
			{`"`, LiteralString, Push("doubleStringTable")},
			Include("string"),
		},
		"doubleString": {
			{`"`, NameFunction, Pop(1)},
			Include("string"),
		},
		"doubleStringTable": {
			{`"`, LiteralString, Pop(1)},
			Include("string"),
		},
		"root": {
			{`\n`, NameFunction, nil},
			Include("comments"),
			{`"""`, Keyword, Push("pyString")},
			{`\s+\|`, Keyword, Push("tableContent")},
			{`"`, NameFunction, Push("doubleString")},
			Include("tableVars"),
			Include("numbers"),
			{`(\s*)(@[^@\r\n\t ]+)`, ByGroups(NameFunction, NameTag), nil},
			{stepKeywords, ByGroups(NameFunction, Keyword), Push("stepContentRoot")},
			{featureKeywords, ByGroups(Keyword, Keyword, NameFunction), Push("narrative")},
			{featureElementKeywords, ByGroups(NameFunction, Keyword, Keyword, NameFunction), Push("featureElements")},
			{examplesKeywords, ByGroups(NameFunction, Keyword, Keyword, NameFunction), Push("examplesTable")},
			{`(\s|.)`, NameFunction, nil},
		},
	},
))

M vendor/github.com/alecthomas/chroma/lexers/internal/api.go => vendor/github.com/alecthomas/chroma/lexers/internal/api.go +6 -5
@@ 37,19 37,20 @@ func Names(withAliases bool) []string {

// Get a Lexer by name, alias or file extension.
func Get(name string) chroma.Lexer {
	candidates := chroma.PrioritisedLexers{}
	if lexer := Registry.byName[name]; lexer != nil {
		candidates = append(candidates, lexer)
		return lexer
	}
	if lexer := Registry.byAlias[name]; lexer != nil {
		candidates = append(candidates, lexer)
		return lexer
	}
	if lexer := Registry.byName[strings.ToLower(name)]; lexer != nil {
		candidates = append(candidates, lexer)
		return lexer
	}
	if lexer := Registry.byAlias[strings.ToLower(name)]; lexer != nil {
		candidates = append(candidates, lexer)
		return lexer
	}

	candidates := chroma.PrioritisedLexers{}
	// Try file extension.
	if lexer := Match("filename." + name); lexer != nil {
		candidates = append(candidates, lexer)

M vendor/github.com/alecthomas/chroma/lexers/j/jsx.go => vendor/github.com/alecthomas/chroma/lexers/j/jsx.go +3 -2
@@ 69,8 69,9 @@ var JSX = internal.Register(MustNewLexer(
			Include("root"),
		},
		"jsx": {
			{`(<)([\w]+)`, ByGroups(Punctuation, NameTag), Push("tag")},
			{`(<)(/)([\w]+)(>)`, ByGroups(Punctuation, Punctuation, NameTag, Punctuation), nil},
			{`(<)(/?)(>)`, ByGroups(Punctuation, Punctuation, Punctuation), nil},
			{`(<)([\w\.]+)`, ByGroups(Punctuation, NameTag), Push("tag")},
			{`(<)(/)([\w\.]+)(>)`, ByGroups(Punctuation, Punctuation, NameTag, Punctuation), nil},
		},
		"tag": {
			{`\s+`, Text, nil},

A vendor/github.com/alecthomas/chroma/lexers/r/reasonml.go => vendor/github.com/alecthomas/chroma/lexers/r/reasonml.go +67 -0
@@ 0,0 1,67 @@
package r

import (
	. "github.com/alecthomas/chroma" // nolint
	"github.com/alecthomas/chroma/lexers/internal"
)

// Reasonml lexer.
var Reasonml = internal.Register(MustNewLexer(
	&Config{
		Name:      "ReasonML",
		Aliases:   []string{"reason", "reasonml"},
		Filenames: []string{"*.re", "*.rei"},
		MimeTypes: []string{"text/x-reasonml"},
	},
	Rules{
		"escape-sequence": {
			{`\\[\\"\'ntbr]`, LiteralStringEscape, nil},
			{`\\[0-9]{3}`, LiteralStringEscape, nil},
			{`\\x[0-9a-fA-F]{2}`, LiteralStringEscape, nil},
		},
		"root": {
			{`\s+`, Text, nil},
			{`false|true|\(\)|\[\]`, NameBuiltinPseudo, nil},
			{`\b([A-Z][\w\']*)(?=\s*\.)`, NameNamespace, Push("dotted")},
			{`\b([A-Z][\w\']*)`, NameClass, nil},
			{`//.*?\n`, CommentSingle, nil},
			{`\/\*(?![\/])`, CommentMultiline, Push("comment")},
			{`\b(as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|false|for|fun|esfun|function|functor|if|in|include|inherit|initializer|lazy|let|switch|module|pub|mutable|new|nonrec|object|of|open|pri|rec|sig|struct|then|to|true|try|type|val|virtual|when|while|with)\b`, Keyword, nil},
			{"(~|\\}|\\|]|\\||\\|\\||\\{<|\\{|`|_|]|\\[\\||\\[>|\\[<|\\[|\\?\\?|\\?|>\\}|>]|>|=|<-|<|;;|;|:>|:=|::|:|\\.\\.\\.|\\.\\.|\\.|=>|-\\.|-|,|\\+|\\*|\\)|\\(|&&|&|#|!=)", OperatorWord, nil},
			{`([=<>@^|&+\*/$%-]|[!?~])?[!$%&*+\./:<=>?@^|~-]`, Operator, nil},
			{`\b(and|asr|land|lor|lsl|lsr|lxor|mod|or)\b`, OperatorWord, nil},
			{`\b(unit|int|float|bool|string|char|list|array)\b`, KeywordType, nil},
			{`[^\W\d][\w']*`, Name, nil},
			{`-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)`, LiteralNumberFloat, nil},
			{`0[xX][\da-fA-F][\da-fA-F_]*`, LiteralNumberHex, nil},
			{`0[oO][0-7][0-7_]*`, LiteralNumberOct, nil},
			{`0[bB][01][01_]*`, LiteralNumberBin, nil},
			{`\d[\d_]*`, LiteralNumberInteger, nil},
			{`'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'`, LiteralStringChar, nil},
			{`'.'`, LiteralStringChar, nil},
			{`'`, Keyword, nil},
			{`"`, LiteralStringDouble, Push("string")},
			{`[~?][a-z][\w\']*:`, NameVariable, nil},
		},
		"comment": {
			{`[^\/*]+`, CommentMultiline, nil},
			{`\/\*`, CommentMultiline, Push()},
			{`\*\/`, CommentMultiline, Pop(1)},
			{`[\*]`, CommentMultiline, nil},
		},
		"string": {
			{`[^\\"]+`, LiteralStringDouble, nil},
			Include("escape-sequence"),
			{`\\\n`, LiteralStringDouble, nil},
			{`"`, LiteralStringDouble, Pop(1)},
		},
		"dotted": {
			{`\s+`, Text, nil},
			{`\.`, Punctuation, nil},
			{`[A-Z][\w\']*(?=\s*\.)`, NameNamespace, nil},
			{`[A-Z][\w\']*`, NameClass, Pop(1)},
			{`[a-z_][\w\']*`, Name, Pop(1)},
			Default(Pop(1)),
		},
	},
))

M vendor/github.com/alecthomas/chroma/lexers/t/typescript.go => vendor/github.com/alecthomas/chroma/lexers/t/typescript.go +25 -1
@@ 9,7 9,7 @@ import (
var TypeScript = internal.Register(MustNewLexer(
	&Config{
		Name:      "TypeScript",
		Aliases:   []string{"ts", "typescript"},
		Aliases:   []string{"ts", "tsx", "typescript"},
		Filenames: []string{"*.ts", "*.tsx"},
		MimeTypes: []string{"text/x-typescript"},
		DotAll:    true,


@@ 32,6 32,7 @@ var TypeScript = internal.Register(MustNewLexer(
			{`\n`, Text, Pop(1)},
		},
		"root": {
			Include("jsx"),
			{`^(?=\s|/|<!--)`, Text, Push("slashstartsregex")},
			Include("commentsandwhitespace"),
			{`\+\+|--|~|&&|\?|:|\|\||\\(?=\n)|(<<|>>>?|==?|!=?|[-<>+*%&|^/])=?`, Operator, Push("slashstartsregex")},


@@ 69,5 70,28 @@ var TypeScript = internal.Register(MustNewLexer(
			{`\}`, LiteralStringInterpol, Pop(1)},
			Include("root"),
		},
		"jsx": {
			{`(<)(/?)(>)`, ByGroups(Punctuation, Punctuation, Punctuation), nil},
			{`(<)([\w\.]+)`, ByGroups(Punctuation, NameTag), Push("tag")},
			{`(<)(/)([\w\.]*)(>)`, ByGroups(Punctuation, Punctuation, NameTag, Punctuation), nil},
		},
		"tag": {
			{`\s+`, Text, nil},
			{`([\w]+\s*)(=)(\s*)`, ByGroups(NameAttribute, Operator, Text), Push("attr")},
			{`[{}]+`, Punctuation, nil},
			{`[\w\.]+`, NameAttribute, nil},
			{`(/?)(\s*)(>)`, ByGroups(Punctuation, Text, Punctuation), Pop(1)},
		},
		"attr": {
			{`{`, Punctuation, Push("expression")},
			{`".*?"`, LiteralString, Pop(1)},
			{`'.*?'`, LiteralString, Pop(1)},
			Default(Pop(1)),
		},
		"expression": {
			{`{`, Punctuation, Push()},
			{`}`, Punctuation, Pop(1)},
			Include("root"),
		},
	},
))

A vendor/github.com/alecthomas/chroma/lexers/y/yang.go => vendor/github.com/alecthomas/chroma/lexers/y/yang.go +67 -0
@@ 0,0 1,67 @@
package y

import (
	. "github.com/alecthomas/chroma" // nolint
	"github.com/alecthomas/chroma/lexers/internal"
)

var YANG = internal.Register(MustNewLexer(
	&Config{
		Name:      "YANG",
		Aliases:   []string{"yang"},
		Filenames: []string{"*.yang"},
		MimeTypes: []string{"application/yang"},
	},
	Rules{
		"root": {
			{`\s+`, Whitespace, nil},
			{`[\{\}\;]+`, Punctuation, nil},
			{`(?<![\-\w])(and|or|not|\+|\.)(?![\-\w])`, Operator, nil},

			{`"(?:\\"|[^"])*?"`, StringDouble, nil},
			{`'(?:\\'|[^'])*?'`, StringSingle, nil},

			{`/\*`, CommentMultiline, Push("comments")},
			{`//.*?$`, CommentSingle, nil},

			//match BNF stmt for `node-identifier` with [ prefix ":"]
			{`(?:^|(?<=[\s{};]))([\w.-]+)(:)([\w.-]+)(?=[\s{};])`, ByGroups(KeywordNamespace, Punctuation, Text), nil},

			//match BNF stmt `date-arg-str`
			{`([0-9]{4}\-[0-9]{2}\-[0-9]{2})(?=[\s\{\}\;])`, LiteralDate, nil},
			{`([0-9]+\.[0-9]+)(?=[\s\{\}\;])`, NumberFloat, nil},
			{`([0-9]+)(?=[\s\{\}\;])`, NumberInteger, nil},

			//TOP_STMTS_KEYWORDS
			{Words(``, `(?=[^\w\-\:])`, `module`, `submodule`), Keyword, nil},
			//MODULE_HEADER_STMT_KEYWORDS
			{Words(``, `(?=[^\w\-\:])`, `belongs-to`, `namespace`, `prefix`, `yang-version`), Keyword, nil},
			//META_STMT_KEYWORDS
			{Words(``, `(?=[^\w\-\:])`, `contact`, `description`, `organization`, `reference`, `revision`), Keyword, nil},
			//LINKAGE_STMTS_KEYWORDS
			{Words(``, `(?=[^\w\-\:])`, `import`, `include`, `revision-date`), Keyword, nil},
			//BODY_STMT_KEYWORDS
			{Words(``, `(?=[^\w\-\:])`, `action`, `argument`, `augment`, `deviation`, `extension`, `feature`, `grouping`, `identity`, `if-feature`, `input`, `notification`, `output`, `rpc`, `typedef`), Keyword, nil},
			//DATA_DEF_STMT_KEYWORDS
			{Words(``, `(?=[^\w\-\:])`, `anydata`, `anyxml`, `case`, `choice`, `config`, `container`, `deviate`, `leaf`, `leaf-list`, `list`, `must`, `presence`, `refine`, `uses`, `when`), Keyword, nil},
			//TYPE_STMT_KEYWORDS
			{Words(``, `(?=[^\w\-\:])`, `base`, `bit`, `default`, `enum`, `error-app-tag`, `error-message`, `fraction-digits`, `length`, `max-elements`, `min-elements`, `modifier`, `ordered-by`, `path`, `pattern`, `position`, `range`, `require-instance`, `status`, `type`, `units`, `value`, `yin-element`), Keyword, nil},
			//LIST_STMT_KEYWORDS
			{Words(``, `(?=[^\w\-\:])`, `key`, `mandatory`, `unique`), Keyword, nil},

			//CONSTANTS_KEYWORDS - RFC7950 other keywords
			{Words(``, `(?=[^\w\-\:])`, `add`, `current`, `delete`, `deprecated`, `false`, `invert-match`, `max`, `min`, `not-supported`, `obsolete`, `replace`, `true`, `unbounded`, `user`), NameClass, nil},

			//RFC7950 Built-In Types
			{Words(``, `(?=[^\w\-\:])`, `binary`, `bits`, `boolean`, `decimal64`, `empty`, `enumeration`, `identityref`, `instance-identifier`, `int16`, `int32`, `int64`, `int8`, `leafref`, `string`, `uint16`, `uint32`, `uint64`, `uint8`, `union`), NameClass, nil},

			{`[^;{}\s\'\"]+`, Text, nil},
		},
		"comments": {
			{`[^*/]`, CommentMultiline, nil},
			{`/\*`, CommentMultiline, Push("comment")},
			{`\*/`, CommentMultiline, Pop(1)},
			{`[*/]`, CommentMultiline, nil},
		},
	},
))

M vendor/github.com/aws/aws-sdk-go/aws/endpoints/defaults.go => vendor/github.com/aws/aws-sdk-go/aws/endpoints/defaults.go +78 -1
@@ 724,6 724,7 @@ var awsPartition = partition{
				Protocols: []string{"http", "https"},
			},
			Endpoints: endpoints{
				"ap-east-1":      endpoint{},
				"ap-northeast-1": endpoint{},
				"ap-northeast-2": endpoint{},
				"ap-south-1":     endpoint{},


@@ 731,8 732,12 @@ var awsPartition = partition{
				"ap-southeast-2": endpoint{},
				"ca-central-1":   endpoint{},
				"eu-central-1":   endpoint{},
				"eu-north-1":     endpoint{},
				"eu-west-1":      endpoint{},
				"eu-west-2":      endpoint{},
				"eu-west-3":      endpoint{},
				"me-south-1":     endpoint{},
				"sa-east-1":      endpoint{},
				"us-east-1":      endpoint{},
				"us-east-2":      endpoint{},
				"us-west-1":      endpoint{},


@@ 855,6 860,7 @@ var awsPartition = partition{
		"cloud9": service{

			Endpoints: endpoints{
				"ap-east-1":      endpoint{},
				"ap-northeast-1": endpoint{},
				"ap-northeast-2": endpoint{},
				"ap-south-1":     endpoint{},


@@ 865,8 871,12 @@ var awsPartition = partition{
				"eu-north-1":     endpoint{},
				"eu-west-1":      endpoint{},
				"eu-west-2":      endpoint{},
				"eu-west-3":      endpoint{},
				"me-south-1":     endpoint{},
				"sa-east-1":      endpoint{},
				"us-east-1":      endpoint{},
				"us-east-2":      endpoint{},
				"us-west-1":      endpoint{},
				"us-west-2":      endpoint{},
			},
		},


@@ 1984,6 1994,48 @@ var awsPartition = partition{
				"us-west-2":  endpoint{},
			},
		},
		"eks": service{
			Defaults: endpoint{
				Protocols: []string{"http", "https"},
			},
			Endpoints: endpoints{
				"ap-east-1":      endpoint{},
				"ap-northeast-1": endpoint{},
				"ap-northeast-2": endpoint{},
				"ap-south-1":     endpoint{},
				"ap-southeast-1": endpoint{},
				"ap-southeast-2": endpoint{},
				"ca-central-1":   endpoint{},
				"eu-central-1":   endpoint{},
				"eu-north-1":     endpoint{},
				"eu-west-1":      endpoint{},
				"eu-west-2":      endpoint{},
				"eu-west-3":      endpoint{},
				"fips-us-east-1": endpoint{
					Hostname: "fips.eks.us-east-1.amazonaws.com",
					CredentialScope: credentialScope{
						Region: "us-east-1",
					},
				},
				"fips-us-east-2": endpoint{
					Hostname: "fips.eks.us-east-2.amazonaws.com",
					CredentialScope: credentialScope{
						Region: "us-east-2",
					},
				},
				"fips-us-west-2": endpoint{
					Hostname: "fips.eks.us-west-2.amazonaws.com",
					CredentialScope: credentialScope{
						Region: "us-west-2",
					},
				},
				"me-south-1": endpoint{},
				"sa-east-1":  endpoint{},
				"us-east-1":  endpoint{},
				"us-east-2":  endpoint{},
				"us-west-2":  endpoint{},
			},
		},
		"elasticache": service{

			Endpoints: endpoints{


@@ 5289,6 5341,7 @@ var awsPartition = partition{
		"storagegateway": service{

			Endpoints: endpoints{
				"af-south-1":     endpoint{},
				"ap-east-1":      endpoint{},
				"ap-northeast-1": endpoint{},
				"ap-northeast-2": endpoint{},


@@ 5298,6 5351,7 @@ var awsPartition = partition{
				"ca-central-1":   endpoint{},
				"eu-central-1":   endpoint{},
				"eu-north-1":     endpoint{},
				"eu-south-1":     endpoint{},
				"eu-west-1":      endpoint{},
				"eu-west-2":      endpoint{},
				"eu-west-3":      endpoint{},


@@ 6190,6 6244,15 @@ var awscnPartition = partition{
				"cn-northwest-1": endpoint{},
			},
		},
		"eks": service{
			Defaults: endpoint{
				Protocols: []string{"http", "https"},
			},
			Endpoints: endpoints{
				"cn-north-1":     endpoint{},
				"cn-northwest-1": endpoint{},
			},
		},
		"elasticache": service{

			Endpoints: endpoints{


@@ 6780,7 6843,9 @@ var awsusgovPartition = partition{
		"autoscaling": service{

			Endpoints: endpoints{
				"us-gov-east-1": endpoint{},
				"us-gov-east-1": endpoint{
					Protocols: []string{"http", "https"},
				},
				"us-gov-west-1": endpoint{
					Protocols: []string{"http", "https"},
				},


@@ 7521,6 7586,18 @@ var awsusgovPartition = partition{
		"rds": service{

			Endpoints: endpoints{
				"rds.us-gov-east-1": endpoint{
					Hostname: "rds.us-gov-east-1.amazonaws.com",
					CredentialScope: credentialScope{
						Region: "us-gov-east-1",
					},
				},
				"rds.us-gov-west-1": endpoint{
					Hostname: "rds.us-gov-west-1.amazonaws.com",
					CredentialScope: credentialScope{
						Region: "us-gov-west-1",
					},
				},
				"us-gov-east-1": endpoint{},
				"us-gov-west-1": endpoint{},
			},

M vendor/github.com/aws/aws-sdk-go/aws/version.go => vendor/github.com/aws/aws-sdk-go/aws/version.go +1 -1
@@ 5,4 5,4 @@ package aws
const SDKName = "aws-sdk-go"

// SDKVersion is the version of this SDK
const SDKVersion = "1.30.23"
const SDKVersion = "1.30.27"

M vendor/github.com/klauspost/reedsolomon/.travis.yml => vendor/github.com/klauspost/reedsolomon/.travis.yml +44 -13
@@ 1,10 1,15 @@
language: go

sudo: false

os:
  - linux
  - osx 
  - osx
  - windows

arch:
  - amd64
  - arm64
  - ppc64le
  - s390x

go:
  - 1.12.x


@@ 17,21 22,47 @@ install:

script: 
 - go vet ./...
 - go test -v -cpu=1,2,4 .
 - go test -v -cpu=1,2,4 -short -race .
 - go test -no-avx512
 - go test -no-avx512 -no-avx2
 - go test -tags=noasm -v -cpu=1,4 -short -race .
 - go test -cpu=1,2 .
 - go test -tags=noasm -cpu=1,2 .
 - go build examples/simple-decoder.go
 - go build examples/simple-encoder.go
 - go build examples/stream-decoder.go
 - go build examples/stream-encoder.go
 - diff <(gofmt -d .) <("")
 - GOARCH=386 GOOS=linux go build .
 - GOARCH=arm64 GOOS=linux go build .
 - GOARCH=ppc64le GOOS=linux go build .

matrix:
jobs:
  allow_failures:
    - go: 'master'
  fast_finish: true
  include:
    - stage: gofmt
      go: 1.14.x
      os: linux
      arch: amd64
      script:
        - diff <(gofmt -d .) <("")
    - stage: race
      go: 1.14.x
      os: linux
      arch: amd64
      script:
        - go test -cpu=1 -short -race .
        - go test -cpu=2 -short -race .
        - go test -tags=noasm -cpu=1 -short -race .
        - go test -tags=noasm -cpu=4 -short -race .
        - go test -no-avx512 -short -race .
        - go test -no-avx512 -no-avx2 -short -race .
        - go test -no-avx512 -no-avx2 -no-ssse3 -short -race .
    - stage: amd64-noasm
      go: 1.14.x
      os: linux
      arch: amd64
      script:
        - go test -no-avx512
        - go test -no-avx512 -no-avx2
        - go test -no-avx512 -no-avx2 -no-ssse3
    - stage: i386
      go: 1.14.x
      os: linux
      arch: amd64
      script:
        - GOOS=linux GOARCH=386 go test -short .

M vendor/github.com/klauspost/reedsolomon/README.md => vendor/github.com/klauspost/reedsolomon/README.md +120 -52
@@ 8,7 8,8 @@

Reed-Solomon Erasure Coding in Go, with speeds exceeding 1GB/s/cpu core implemented in pure Go.

This is a Go port of the [JavaReedSolomon](https://github.com/Backblaze/JavaReedSolomon) library released by [Backblaze](http://backblaze.com), with some additional optimizations.
This is a Go port of the [JavaReedSolomon](https://github.com/Backblaze/JavaReedSolomon) library released by 
[Backblaze](http://backblaze.com), with some additional optimizations.

For an introduction on erasure coding, see the post on the [Backblaze blog](https://www.backblaze.com/blog/reed-solomon/).



@@ 24,13 25,23 @@ go get -u github.com/klauspost/reedsolomon

# Changes

## May 2020

Numerous updates:

* Much better performance when using a limited number of goroutines.
* AVX512 is now using multiple cores.
* Stream processing overhaul, big speedups in most cases.
* AVX512 optimizations

## March 6, 2019

The pure Go implementation is about 30% faster. Minor tweaks to assembler implementations.

## February 8, 2019

AVX512 accelerated version added for Intel Skylake CPUs. This can give up to a 4x speed improvement as compared to AVX2. See [here](https://github.com/klauspost/reedsolomon#performance-on-avx512) for more details.
AVX512 accelerated version added for Intel Skylake CPUs. This can give up to a 4x speed improvement as compared to AVX2.
See [here](https://github.com/klauspost/reedsolomon#performance-on-avx512) for more details.

## December 18, 2018



@@ 38,49 49,73 @@ Assembly code for ppc64le has been contributed, this boosts performance by about

## November 18, 2017

Added [WithAutoGoroutines](https://godoc.org/github.com/klauspost/reedsolomon#WithAutoGoroutines) which will attempt to calculate the optimal number of goroutines to use based on your expected shard size and detected CPU.
Added [WithAutoGoroutines](https://godoc.org/github.com/klauspost/reedsolomon#WithAutoGoroutines) which will attempt 
to calculate the optimal number of goroutines to use based on your expected shard size and detected CPU.

## October 1, 2017

* [Cauchy Matrix](https://godoc.org/github.com/klauspost/reedsolomon#WithCauchyMatrix) is now an option. Thanks to [templexxx](https://github.com/templexxx) for the basis of this.
* Default maximum number of [goroutines](https://godoc.org/github.com/klauspost/reedsolomon#WithMaxGoroutines) has been increased for better multi-core scaling.
* After several requests the Reconstruct and ReconstructData now slices of zero length but sufficient capacity to be used instead of allocating new memory.
* [Cauchy Matrix](https://godoc.org/github.com/klauspost/reedsolomon#WithCauchyMatrix) is now an option. 
Thanks to [templexxx](https://github.com/templexxx) for the basis of this.

* Default maximum number of [goroutines](https://godoc.org/github.com/klauspost/reedsolomon#WithMaxGoroutines) 
has been increased for better multi-core scaling.

* After several requests the Reconstruct and ReconstructData now slices of zero length but sufficient capacity to 
be used instead of allocating new memory.

## August 26, 2017

*  The [`Encoder()`](https://godoc.org/github.com/klauspost/reedsolomon#Encoder) now contains an `Update` function contributed by [chenzhongtao](https://github.com/chenzhongtao).
* [Frank Wessels](https://github.com/fwessels) kindly contributed ARM 64 bit assembly, which gives a huge performance boost on this platform.
*  The [`Encoder()`](https://godoc.org/github.com/klauspost/reedsolomon#Encoder) now contains an `Update` 
function contributed by [chenzhongtao](https://github.com/chenzhongtao).

* [Frank Wessels](https://github.com/fwessels) kindly contributed ARM 64 bit assembly, 
which gives a huge performance boost on this platform.

## July 20, 2017

`ReconstructData` added to [`Encoder`](https://godoc.org/github.com/klauspost/reedsolomon#Encoder) interface. This can cause compatibility issues if you implement your own Encoder. A simple workaround can be added:
`ReconstructData` added to [`Encoder`](https://godoc.org/github.com/klauspost/reedsolomon#Encoder) interface. 
This can cause compatibility issues if you implement your own Encoder. A simple workaround can be added:

```Go
func (e *YourEnc) ReconstructData(shards [][]byte) error {
	return ReconstructData(shards)
}
```

You can of course also do your own implementation. The [`StreamEncoder`](https://godoc.org/github.com/klauspost/reedsolomon#StreamEncoder) handles this without modifying the interface. This is a good lesson on why returning interfaces is not a good design.
You can of course also do your own implementation. 
The [`StreamEncoder`](https://godoc.org/github.com/klauspost/reedsolomon#StreamEncoder) 
handles this without modifying the interface. 
This is a good lesson on why returning interfaces is not a good design.

# Usage

This section assumes you know the basics of Reed-Solomon encoding. A good start is this [Backblaze blog post](https://www.backblaze.com/blog/reed-solomon/).
This section assumes you know the basics of Reed-Solomon encoding. 
A good start is this [Backblaze blog post](https://www.backblaze.com/blog/reed-solomon/).

This package performs the calculation of the parity sets. The usage is therefore relatively simple.

First of all, you need to choose your distribution of data and parity shards. A 'good' distribution is very subjective, and will depend a lot on your usage scenario. A good starting point is above 5 and below 257 data shards (the maximum supported number), and the number of parity shards to be 2 or above, and below the number of data shards.
First of all, you need to choose your distribution of data and parity shards. 
A 'good' distribution is very subjective, and will depend a lot on your usage scenario. 
A good starting point is above 5 and below 257 data shards (the maximum supported number), 
and the number of parity shards to be 2 or above, and below the number of data shards.

To create an encoder with 10 data shards (where your data goes) and 3 parity shards (calculated):
```Go
    enc, err := reedsolomon.New(10, 3)
```
This encoder will work for all parity sets with this distribution of data and parity shards. The error will only be set if you specify 0 or negative values in any of the parameters, or if you specify more than 256 data shards.
This encoder will work for all parity sets with this distribution of data and parity shards. 
The error will only be set if you specify 0 or negative values in any of the parameters, 
or if you specify more than 256 data shards.

The you send and receive data  is a simple slice of byte slices; `[][]byte`. 
In the example above, the top slice must have a length of 13.

The you send and receive data  is a simple slice of byte slices; `[][]byte`. In the example above, the top slice must have a length of 13.
```Go
    data := make([][]byte, 13)
```
You should then fill the 10 first slices with *equally sized* data, and create parity shards that will be populated with parity data. In this case we create the data in memory, but you could for instance also use [mmap](https://github.com/edsrzf/mmap-go) to map files.
You should then fill the 10 first slices with *equally sized* data, 
and create parity shards that will be populated with parity data. In this case we create the data in memory, 
but you could for instance also use [mmap](https://github.com/edsrzf/mmap-go) to map files.

```Go
    // Create all shards, size them at 50000 each


@@ 101,13 136,19 @@ To populate the parity shards, you simply call `Encode()` with your data.
```Go
    err = enc.Encode(data)
```
The only cases where you should get an error is, if the data shards aren't of equal size. The last 3 shards now contain parity data. You can verify this by calling `Verify()`:
The only cases where you should get an error is, if the data shards aren't of equal size. 
The last 3 shards now contain parity data. You can verify this by calling `Verify()`:

```Go
    ok, err = enc.Verify(data)
```

The final (and important) part is to be able to reconstruct missing shards. For this to work, you need to know which parts of your data is missing. The encoder *does not know which parts are invalid*, so if data corruption is a likely scenario, you need to implement a hash check for each shard. If a byte has changed in your set, and you don't know which it is, there is no way to reconstruct the data set.
The final (and important) part is to be able to reconstruct missing shards. 
For this to work, you need to know which parts of your data is missing. 
The encoder *does not know which parts are invalid*, so if data corruption is a likely scenario, 
you need to implement a hash check for each shard. 

If a byte has changed in your set, and you don't know which it is, there is no way to reconstruct the data set.

To indicate missing data, you set the shard to nil before calling `Reconstruct()`:



@@ 138,11 179,13 @@ So to sum up reconstruction:
* You may only supply data you know is valid.
* Invalid shards should be set to nil.

For complete examples of an encoder and decoder see the [examples folder](https://github.com/klauspost/reedsolomon/tree/master/examples).
For complete examples of an encoder and decoder see the 
[examples folder](https://github.com/klauspost/reedsolomon/tree/master/examples).

# Splitting/Joining Data

You might have a large slice of data. To help you split this, there are some helper functions that can split and join a single byte slice.
You might have a large slice of data. 
To help you split this, there are some helper functions that can split and join a single byte slice.

```Go
   bigfile, _ := ioutil.Readfile("myfile.data")


@@ 152,7 195,8 @@ You might have a large slice of data. To help you split this, there are some hel
```
This will split the file into the number of data shards set when creating the encoder and create empty parity shards. 

An important thing to note is that you have to *keep track of the exact input size*. If the size of the input isn't divisible by the number of data shards, extra zeros will be inserted in the last shard.
An important thing to note is that you have to *keep track of the exact input size*. 
If the size of the input isn't divisible by the number of data shards, extra zeros will be inserted in the last shard.

To join a data set, use the `Join()` function, which will join the shards and write it to the `io.Writer` you supply: 
```Go


@@ 162,7 206,9 @@ To join a data set, use the `Join()` function, which will join the shards and wr

# Streaming/Merging

It might seem like a limitation that all data should be in memory, but an important property is that *as long as the number of data/parity shards are the same, you can merge/split data sets*, and they will remain valid as a separate set.
It might seem like a limitation that all data should be in memory, 
but an important property is that *as long as the number of data/parity shards are the same, 
you can merge/split data sets*, and they will remain valid as a separate set.

```Go
    // Split the data set of 50000 elements into two of 25000


@@ 198,26 244,44 @@ It might seem like a limitation that all data should be in memory, but an import
    }
```

This means that if you have a data set that may not fit into memory, you can split processing into smaller blocks. For the best throughput, don't use too small blocks.
This means that if you have a data set that may not fit into memory, you can split processing into smaller blocks. 
For the best throughput, don't use too small blocks.

This also means that you can divide big input up into smaller blocks, and do reconstruction on parts of your data. This doesn't give the same flexibility of a higher number of data shards, but it will be much more performant.
This also means that you can divide big input up into smaller blocks, and do reconstruction on parts of your data. 
This doesn't give the same flexibility of a higher number of data shards, but it will be much more performant.

# Streaming API

There has been added support for a streaming API, to help perform fully streaming operations, which enables you to do the same operations, but on streams. To use the stream API, use [`NewStream`](https://godoc.org/github.com/klauspost/reedsolomon#NewStream) function to create the encoding/decoding interfaces. You can use [`NewStreamC`](https://godoc.org/github.com/klauspost/reedsolomon#NewStreamC) to ready an interface that reads/writes concurrently from the streams.
There has been added support for a streaming API, to help perform fully streaming operations, 
which enables you to do the same operations, but on streams. 
To use the stream API, use [`NewStream`](https://godoc.org/github.com/klauspost/reedsolomon#NewStream) function 
to create the encoding/decoding interfaces. 

Input is delivered as `[]io.Reader`, output as `[]io.Writer`, and functionality corresponds to the in-memory API. Each stream must supply the same amount of data, similar to how each slice must be similar size with the in-memory API. 
If an error occurs in relation to a stream, a [`StreamReadError`](https://godoc.org/github.com/klauspost/reedsolomon#StreamReadError) or [`StreamWriteError`](https://godoc.org/github.com/klauspost/reedsolomon#StreamWriteError) will help you determine which stream was the offender.
You can use [`WithConcurrentStreams`](https://godoc.org/github.com/klauspost/reedsolomon#WithConcurrentStreams) 
to ready an interface that reads/writes concurrently from the streams.

You can specify the size of each operation using 
[`WithStreamBlockSize`](https://godoc.org/github.com/klauspost/reedsolomon#WithStreamBlockSize).
This will set the size of each read/write operation.

Input is delivered as `[]io.Reader`, output as `[]io.Writer`, and functionality corresponds to the in-memory API. 
Each stream must supply the same amount of data, similar to how each slice must be similar size with the in-memory API. 
If an error occurs in relation to a stream, 
a [`StreamReadError`](https://godoc.org/github.com/klauspost/reedsolomon#StreamReadError) 
or [`StreamWriteError`](https://godoc.org/github.com/klauspost/reedsolomon#StreamWriteError) 
will help you determine which stream was the offender.

There is no buffering or timeouts/retry specified. If you want to add that, you need to add it to the Reader/Writer.

For complete examples of a streaming encoder and decoder see the [examples folder](https://github.com/klauspost/reedsolomon/tree/master/examples).
For complete examples of a streaming encoder and decoder see the 
[examples folder](https://github.com/klauspost/reedsolomon/tree/master/examples).

# Advanced Options

You can modify internal options which affects how jobs are split between and processed by goroutines.

To create options, use the WithXXX functions. You can supply options to `New`, `NewStream` and `NewStreamC`. If no Options are supplied, default options are used.
To create options, use the WithXXX functions. You can supply options to `New`, `NewStream`. 
If no Options are supplied, default options are used.

Example of how to supply options:



@@ 227,9 291,11 @@ Example of how to supply options:


# Performance
Performance depends mainly on the number of parity shards. In rough terms, doubling the number of parity shards will double the encoding time.
Performance depends mainly on the number of parity shards. 
In rough terms, doubling the number of parity shards will double the encoding time.

Here are the throughput numbers with some different selections of data and parity shards. For reference each shard is 1MB random data, and 2 CPU cores are used for encoding.
Here are the throughput numbers with some different selections of data and parity shards. 
For reference each shard is 1MB random data, and 2 CPU cores are used for encoding.

| Data | Parity | Parity | MB/s   | SSSE3 MB/s  | SSSE3 Speed | Rel. Speed |
|------|--------|--------|--------|-------------|-------------|------------|


@@ 238,16 304,20 @@ Here are the throughput numbers with some different selections of data and parit
| 10   | 4      | 40%    | 298,38 | 2470,97     | 828%        | 51,79%     |
| 50   | 20     | 40%    | 59,81  | 713,28      | 1193%       | 10,38%     |

If `runtime.GOMAXPROCS()` is set to a value higher than 1, the encoder will use multiple goroutines to perform the calculations in `Verify`, `Encode` and `Reconstruct`.
If `runtime.GOMAXPROCS()` is set to a value higher than 1, 
the encoder will use multiple goroutines to perform the calculations in `Verify`, `Encode` and `Reconstruct`.

Example of performance scaling on AMD Ryzen 3950X - 16 physical cores, 32 logical cores, AVX 2.
The example uses 10 blocks with 1MB data each and 4 parity blocks.

Example of performance scaling on Intel(R) Core(TM) i7-2600 CPU @ 3.40GHz - 4 physical cores, 8 logical cores. The example uses 10 blocks with 16MB data each and 4 parity blocks.
| Threads | Speed      |
|---------|------------|
| 1       | 9979 MB/s  |
| 2       | 18870 MB/s |
| 4       | 33697 MB/s |
| 8       | 51531 MB/s |
| 16      | 59204 MB/s |

| Threads | MB/s    | Speed |
|---------|---------|-------|
| 1       | 1355,11 | 100%  |
| 2       | 2339,78 | 172%  |
| 4       | 3179,33 | 235%  |
| 8       | 4346,18 | 321%  |

Benchmarking `Reconstruct()` followed by a `Verify()` (=`all`) versus just calling `ReconstructData()` (=`data`) gives the following result:
```


@@ 263,26 333,23 @@ BenchmarkReconstruct10x4x16M-8       1484.35      5779.53      3.89x

# Performance on AVX512

The performance on AVX512 has been accelerated for Intel CPUs. This gives speedups on a per-core basis of up to 4x compared to AVX2 as can be seen in the following table:
The performance on AVX512 has been accelerated for Intel CPUs. 
This gives speedups on a per-core basis typically up to 2x compared to 
AVX2 as can be seen in the following table:

```
$ benchcmp avx2.txt avx512.txt
benchmark                      AVX2 MB/s    AVX512 MB/s   speedup
BenchmarkEncode8x8x1M-72       1681.35      4125.64       2.45x
BenchmarkEncode8x4x8M-72       1529.36      5507.97       3.60x
BenchmarkEncode8x8x8M-72        791.16      2952.29       3.73x
BenchmarkEncode8x8x32M-72       573.26      2168.61       3.78x
BenchmarkEncode12x4x12M-72     1234.41      4912.37       3.98x
BenchmarkEncode16x4x16M-72     1189.59      5138.01       4.32x
BenchmarkEncode24x8x24M-72      690.68      2583.70       3.74x
BenchmarkEncode24x8x48M-72      674.20      2643.31       3.92x
[...]
```

This speedup has been achieved by computing multiple parity blocks in parallel as opposed to one after the other. In doing so it is possible to minimize the memory bandwidth required for loading all data shards. At the same time the calculations are performed in the 512-bit wide ZMM registers and the surplus of ZMM registers (32 in total) is used to keep more data around (most notably the matrix coefficients).
This speedup has been achieved by computing multiple parity blocks in parallel as opposed to one after the other. 
In doing so it is possible to minimize the memory bandwidth required for loading all data shards. 
At the same time the calculations are performed in the 512-bit wide ZMM registers and the surplus of ZMM 
registers (32 in total) is used to keep more data around (most notably the matrix coefficients).

# Performance on ARM64 NEON

By exploiting NEON instructions the performance for ARM has been accelerated. Below are the performance numbers for a single core on an ARM Cortex-A53 CPU @ 1.2GHz (Debian 8.0 Jessie running Go: 1.7.4):
By exploiting NEON instructions the performance for ARM has been accelerated. 
Below are the performance numbers for a single core on an ARM Cortex-A53 CPU @ 1.2GHz (Debian 8.0 Jessie running Go: 1.7.4):

| Data | Parity | Parity | ARM64 Go MB/s | ARM64 NEON MB/s | NEON Speed |
|------|--------|--------|--------------:|----------------:|-----------:|


@@ 292,7 359,8 @@ By exploiting NEON instructions the performance for ARM has been accelerated. Be

# Performance on ppc64le

The performance for ppc64le has been accelerated. This gives roughly a 10x performance improvement on this architecture as can been seen below:
The performance for ppc64le has been accelerated. 
This gives roughly a 10x performance improvement on this architecture as can been seen below:

```
benchmark                      old MB/s     new MB/s     speedup

M vendor/github.com/klauspost/reedsolomon/galoisAvx512_amd64.go => vendor/github.com/klauspost/reedsolomon/galoisAvx512_amd64.go +81 -38
@@ 10,6 10,9 @@ package reedsolomon
import "sync"

//go:noescape
func _galMulAVX512Parallel81(in, out [][]byte, matrix *[matrixSize81]byte, addTo bool)

//go:noescape
func _galMulAVX512Parallel82(in, out [][]byte, matrix *[matrixSize82]byte, addTo bool)

//go:noescape


@@ 17,13 20,39 @@ func _galMulAVX512Parallel84(in, out [][]byte, matrix *[matrixSize84]byte, addTo

const (
	dimIn        = 8                            // Number of input rows processed simultaneously
	dimOut81     = 1                            // Number of output rows processed simultaneously for x1 routine
	dimOut82     = 2                            // Number of output rows processed simultaneously for x2 routine
	dimOut84     = 4                            // Number of output rows processed simultaneously for x4 routine
	matrixSize81 = (16 + 16) * dimIn * dimOut81 // Dimension of slice of matrix coefficient passed into x1 routine
	matrixSize82 = (16 + 16) * dimIn * dimOut82 // Dimension of slice of matrix coefficient passed into x2 routine
	matrixSize84 = (16 + 16) * dimIn * dimOut84 // Dimension of slice of matrix coefficient passed into x4 routine
)

// Construct block of matrix coefficients for 2 outputs rows in parallel
// Construct block of matrix coefficients for single output row in parallel
func setupMatrix81(matrixRows [][]byte, inputOffset, outputOffset int, matrix *[matrixSize81]byte) {
	offset := 0
	for c := inputOffset; c < inputOffset+dimIn; c++ {
		for iRow := outputOffset; iRow < outputOffset+dimOut81; iRow++ {
			if c < len(matrixRows[iRow]) {
				coeff := matrixRows[iRow][c]
				copy(matrix[offset*32:], mulTableLow[coeff][:])
				copy(matrix[offset*32+16:], mulTableHigh[coeff][:])
			} else {
				// coefficients not used for this input shard (so null out)
				v := matrix[offset*32 : offset*32+32]
				for i := range v {
					v[i] = 0
				}
			}
			offset += dimIn
			if offset >= dimIn*dimOut81 {
				offset -= dimIn*dimOut81 - 1
			}
		}
	}
}

// Construct block of matrix coefficients for 2 output rows in parallel
func setupMatrix82(matrixRows [][]byte, inputOffset, outputOffset int, matrix *[matrixSize82]byte) {
	offset := 0
	for c := inputOffset; c < inputOffset+dimIn; c++ {


@@ 47,7 76,7 @@ func setupMatrix82(matrixRows [][]byte, inputOffset, outputOffset int, matrix *[
	}
}

// Construct block of matrix coefficients for 4 outputs rows in parallel
// Construct block of matrix coefficients for 4 output rows in parallel
func setupMatrix84(matrixRows [][]byte, inputOffset, outputOffset int, matrix *[matrixSize84]byte) {
	offset := 0
	for c := inputOffset; c < inputOffset+dimIn; c++ {


@@ 71,6 100,41 @@ func setupMatrix84(matrixRows [][]byte, inputOffset, outputOffset int, matrix *[
	}
}

// Invoke AVX512 routine for single output row in parallel
func galMulAVX512Parallel81(in, out [][]byte, matrixRows [][]byte, inputOffset, outputOffset, start, stop int, matrix81 *[matrixSize81]byte) {
	done := stop - start
	if done <= 0 {
		return
	}

	inputEnd := inputOffset + dimIn
	if inputEnd > len(in) {
		inputEnd = len(in)
	}
	outputEnd := outputOffset + dimOut81
	if outputEnd > len(out) {
		outputEnd = len(out)
	}

	// We know the max size, alloc temp array.
	var inTmp [dimIn][]byte
	for i, v := range in[inputOffset:inputEnd] {
		inTmp[i] = v[start:stop]
	}
	var outTmp [dimOut81][]byte
	for i, v := range out[outputOffset:outputEnd] {
		outTmp[i] = v[start:stop]
	}

	addTo := inputOffset != 0 // Except for the first input column, add to previous results
	_galMulAVX512Parallel81(inTmp[:inputEnd-inputOffset], outTmp[:outputEnd-outputOffset], matrix81, addTo)

	done = start + ((done >> 6) << 6)
	if done < stop {
		galMulAVX512LastInput(inputOffset, inputEnd, outputOffset, outputEnd, matrixRows, done, stop, out, in)
	}
}

// Invoke AVX512 routine for 2 output rows in parallel
func galMulAVX512Parallel82(in, out [][]byte, matrixRows [][]byte, inputOffset, outputOffset, start, stop int, matrix82 *[matrixSize82]byte) {
	done := stop - start


@@ 101,23 165,8 @@ func galMulAVX512Parallel82(in, out [][]byte, matrixRows [][]byte, inputOffset, 
	_galMulAVX512Parallel82(inTmp[:inputEnd-inputOffset], outTmp[:outputEnd-outputOffset], matrix82, addTo)

	done = start + ((done >> 6) << 6)
	if done == stop {
		return
	}

	for c := inputOffset; c < inputEnd; c++ {
		for iRow := outputOffset; iRow < outputEnd; iRow++ {
			if c < len(matrixRows[iRow]) {
				mt := mulTable[matrixRows[iRow][c]][:256]
				for i := done; i < stop; i++ {
					if c == 0 { // only set value for first input column
						out[iRow][i] = mt[in[c][i]]
					} else { // and add for all others
						out[iRow][i] ^= mt[in[c][i]]
					}
				}
			}
		}
	if done < stop {
		galMulAVX512LastInput(inputOffset, inputEnd, outputOffset, outputEnd, matrixRows, done, stop, out, in)
	}
}



@@ 150,12 199,13 @@ func galMulAVX512Parallel84(in, out [][]byte, matrixRows [][]byte, inputOffset, 
	addTo := inputOffset != 0 // Except for the first input column, add to previous results
	_galMulAVX512Parallel84(inTmp[:inputEnd-inputOffset], outTmp[:outputEnd-outputOffset], matrix84, addTo)

	done = (done >> 6) << 6
	done += start
	if done == stop {
		return
	done = start + ((done >> 6) << 6)
	if done < stop {
		galMulAVX512LastInput(inputOffset, inputEnd, outputOffset, outputEnd, matrixRows, done, stop, out, in)
	}
}

func galMulAVX512LastInput(inputOffset int, inputEnd int, outputOffset int, outputEnd int, matrixRows [][]byte, done int, stop int, out [][]byte, in [][]byte) {
	for c := inputOffset; c < inputEnd; c++ {
		for iRow := outputOffset; iRow < outputEnd; iRow++ {
			if c < len(matrixRows[iRow]) {


@@ 183,6 233,7 @@ func (r reedSolomon) codeSomeShardsAvx512(matrixRows, inputs, outputs [][]byte, 
	for start < byteCount {
		matrix84 := [matrixSize84]byte{}
		matrix82 := [matrixSize82]byte{}
		matrix81 := [matrixSize81]byte{}

		outputRow := 0
		// First process (multiple) batches of 4 output rows in parallel


@@ 204,12 255,9 @@ func (r reedSolomon) codeSomeShardsAvx512(matrixRows, inputs, outputs [][]byte, 
		}
		// Lastly, we may have a single output row left (for uneven parity)
		if outputRow < outputCount {
			for c := 0; c < r.DataShards; c++ {
				if c == 0 {
					galMulSlice(matrixRows[outputRow][c], inputs[c], outputs[outputRow], &r.o)
				} else {
					galMulSliceXor(matrixRows[outputRow][c], inputs[c], outputs[outputRow], &r.o)
				}
			for inputRow := 0; inputRow < len(inputs); inputRow += dimIn {
				setupMatrix81(matrixRows, inputRow, outputRow, &matrix81)
				galMulAVX512Parallel81(inputs, outputs, matrixRows, inputRow, outputRow, start, end, &matrix81)
			}
		}



@@ 245,6 293,7 @@ func (r reedSolomon) codeSomeShardsAvx512P(matrixRows, inputs, outputs [][]byte,
			// Loop for each round.
			matrix84 := [matrixSize84]byte{}
			matrix82 := [matrixSize82]byte{}
			matrix81 := [matrixSize81]byte{}
			for start < grStop {
				outputRow := 0
				// First process (multiple) batches of 4 output rows in parallel


@@ 268,15 317,9 @@ func (r reedSolomon) codeSomeShardsAvx512P(matrixRows, inputs, outputs [][]byte,
				}
				// Lastly, we may have a single output row left (for uneven parity)
				if outputRow < outputCount {
					for c := 0; c < r.DataShards; c++ {
						in := inputs[c][start:stop]
						for iRow := 0; iRow < outputCount; iRow++ {
							if c == 0 {
								galMulSlice(matrixRows[iRow][c], in, outputs[iRow][start:stop], &r.o)
							} else {
								galMulSliceXor(matrixRows[iRow][c], in, outputs[iRow][start:stop], &r.o)
							}
						}
					for inputRow := 0; inputRow < len(inputs); inputRow += dimIn {
						setupMatrix81(matrixRows, inputRow, outputRow, &matrix81)
						galMulAVX512Parallel81(inputs, outputs, matrixRows, inputRow, outputRow, start, stop, &matrix81)
					}
				}
				start = stop

M vendor/github.com/klauspost/reedsolomon/galoisAvx512_amd64.s => vendor/github.com/klauspost/reedsolomon/galoisAvx512_amd64.s +163 -73
@@ 3,33 3,123 @@
// Copyright 2015, Klaus Post, see LICENSE for details.
// Copyright 2019, Minio, Inc.

#define LOAD(OFFSET)           \
	MOVQ       OFFSET(SI), BX  \
	VMOVDQU64  (BX)(R11*1), Z0 \
	VPSRLQ     $4, Z0, Z1      \ // high input
	VPANDQ     Z2, Z0, Z0      \ // low input
	VPANDQ     Z2, Z1, Z1        // high input
#define LOAD(OFFSET) \
	MOVQ      OFFSET(SI), BX  \
	VMOVDQU64 (BX)(R11*1), Z0 \
	VPSRLQ    $4, Z0, Z1      \ // high input
	VPANDQ    Z2, Z0, Z0      \ // low input
	VPANDQ    Z2, Z1, Z1      // high input

#define GALOIS(C1, C2, IN, LO, HI, OUT) \
	VSHUFI64X2 $C1, IN, IN, LO          \
	VSHUFI64X2 $C2, IN, IN, HI          \
	VPSHUFB    Z0, LO, LO               \ // mul low part
	VPSHUFB    Z1, HI, HI               \ // mul high part
	VSHUFI64X2 $C1, IN, IN, LO    \
	VSHUFI64X2 $C2, IN, IN, HI    \
	VPSHUFB    Z0, LO, LO         \ // mul low part
	VPSHUFB    Z1, HI, HI         \ // mul high part
	VPTERNLOGD $0x96, LO, HI, OUT

//
// Process single output row from a total of 8 input rows
//
// func _galMulAVX512Parallel81(in, out [][]byte, matrix *[matrixSize81]byte, addTo bool)
TEXT ·_galMulAVX512Parallel81(SB), 7, $0
	MOVQ  in+0(FP), SI
	MOVQ  8(SI), R9              // R9: len(in)
	SHRQ  $6, R9                 // len(in) / 64
	TESTQ R9, R9
	JZ    done_avx512_parallel81

	MOVQ      matrix+48(FP), SI
	VMOVDQU64 0x000(SI), Z16
	VMOVDQU64 0x040(SI), Z17
	VMOVDQU64 0x080(SI), Z18
	VMOVDQU64 0x0c0(SI), Z19

	MOVQ         $15, BX
	VPBROADCASTB BX, Z2

	MOVB  addTo+56(FP), AX
	IMULQ $-0x1, AX
	KMOVQ AX, K1
	MOVQ  in+0(FP), SI     // SI: &in
	MOVQ  in_len+8(FP), AX // number of inputs
	XORQ  R11, R11
	MOVQ  out+24(FP), DX
	MOVQ  (DX), DX         // DX: &out[0][0]

loopback_avx512_parallel81:
	VMOVDQU64.Z (DX), K1, Z4

	LOAD(0x00)                            // &in[0][0]
	GALOIS(0x00, 0x55, Z16, Z14, Z15, Z4)

	CMPQ AX, $1
	JE   skip_avx512_parallel81

	LOAD(0x18)                            // &in[1][0]
	GALOIS(0xaa, 0xff, Z16, Z14, Z15, Z4)

	CMPQ AX, $2
	JE   skip_avx512_parallel81

	LOAD(0x30)                            // &in[2][0]
	GALOIS(0x00, 0x55, Z17, Z14, Z15, Z4)

	CMPQ AX, $3
	JE   skip_avx512_parallel81

	LOAD(0x48)                            // &in[3][0]
	GALOIS(0xaa, 0xff, Z17, Z14, Z15, Z4)

	CMPQ AX, $4
	JE   skip_avx512_parallel81

	LOAD(0x60)                            // &in[4][0]
	GALOIS(0x00, 0x55, Z18, Z14, Z15, Z4)

	CMPQ AX, $5
	JE   skip_avx512_parallel81

	LOAD(0x78)                            // &in[5][0]
	GALOIS(0xaa, 0xff, Z18, Z14, Z15, Z4)

	CMPQ AX, $6
	JE   skip_avx512_parallel81

	LOAD(0x90)                            // &in[6][0]
	GALOIS(0x00, 0x55, Z19, Z14, Z15, Z4)

	CMPQ AX, $7
	JE   skip_avx512_parallel81

	LOAD(0xa8)                            // &in[7][0]
	GALOIS(0xaa, 0xff, Z19, Z14, Z15, Z4)

skip_avx512_parallel81:
	VMOVDQU64 Z4, (DX)

	ADDQ $64, R11 // in4+=64

	ADDQ $64, DX // out+=64

	SUBQ $1, R9
	JNZ  loopback_avx512_parallel81

done_avx512_parallel81:
	VZEROUPPER
	RET

//
// Process 2 output rows in parallel from a total of 8 input rows
//
// func _galMulAVX512Parallel82(in, out [][]byte, matrix *[matrixSize82]byte, addTo bool)
TEXT ·_galMulAVX512Parallel82(SB), 7, $0
	MOVQ  in+0(FP), SI     //
	MOVQ  8(SI), R9        // R9: len(in)
	SHRQ  $6, R9           // len(in) / 64
	MOVQ  in+0(FP), SI
	MOVQ  8(SI), R9              // R9: len(in)
	SHRQ  $6, R9                 // len(in) / 64
	TESTQ R9, R9
	JZ    done_avx512_parallel82

	MOVQ matrix+48(FP), SI
	MOVQ      matrix+48(FP), SI
	VMOVDQU64 0x000(SI), Z16
	VMOVDQU64 0x040(SI), Z17
	VMOVDQU64 0x080(SI), Z18


@@ 42,70 132,70 @@ TEXT ·_galMulAVX512Parallel82(SB), 7, $0
	MOVQ         $15, BX
	VPBROADCASTB BX, Z2

	MOVB addTo+56(FP), AX
	MOVB  addTo+56(FP), AX
	IMULQ $-0x1, AX
	KMOVQ AX, K1
	MOVQ in+0(FP), SI  //  SI: &in
	MOVQ in_len+8(FP), AX  // number of inputs
	XORQ R11, R11
	MOVQ out+24(FP), DX
	MOVQ 24(DX), CX    //  CX: &out[1][0]
	MOVQ (DX), DX      //  DX: &out[0][0]
	MOVQ  in+0(FP), SI     // SI: &in
	MOVQ  in_len+8(FP), AX // number of inputs
	XORQ  R11, R11
	MOVQ  out+24(FP), DX
	MOVQ  24(DX), CX       // CX: &out[1][0]
	MOVQ  (DX), DX         // DX: &out[0][0]

loopback_avx512_parallel82:
	VMOVDQU64.Z (DX), K1, Z4
	VMOVDQU64.Z (CX), K1, Z5

	LOAD(0x00) // &in[0][0]
	LOAD(0x00)                            // &in[0][0]
	GALOIS(0x00, 0x55, Z16, Z14, Z15, Z4)
	GALOIS(0x00, 0x55, Z20, Z12, Z13, Z5)

    CMPQ AX, $1
    JE skip_avx512_parallel82
	CMPQ AX, $1
	JE   skip_avx512_parallel82

	LOAD(0x18) // &in[1][0]
	LOAD(0x18)                            // &in[1][0]
	GALOIS(0xaa, 0xff, Z16, Z14, Z15, Z4)
	GALOIS(0xaa, 0xff, Z20, Z12, Z13, Z5)

    CMPQ AX, $2
    JE skip_avx512_parallel82
	CMPQ AX, $2
	JE   skip_avx512_parallel82

	LOAD(0x30) // &in[2][0]
	LOAD(0x30)                            // &in[2][0]
	GALOIS(0x00, 0x55, Z17, Z14, Z15, Z4)
	GALOIS(0x00, 0x55, Z21, Z12, Z13, Z5)

    CMPQ AX, $3
    JE skip_avx512_parallel82
	CMPQ AX, $3
	JE   skip_avx512_parallel82

	LOAD(0x48) // &in[3][0]
	LOAD(0x48)                            // &in[3][0]
	GALOIS(0xaa, 0xff, Z17, Z14, Z15, Z4)
	GALOIS(0xaa, 0xff, Z21, Z12, Z13, Z5)

    CMPQ AX, $4
    JE skip_avx512_parallel82
	CMPQ AX, $4
	JE   skip_avx512_parallel82

	LOAD(0x60) // &in[4][0]
	LOAD(0x60)                            // &in[4][0]
	GALOIS(0x00, 0x55, Z18, Z14, Z15, Z4)
	GALOIS(0x00, 0x55, Z22, Z12, Z13, Z5)

    CMPQ AX, $5
    JE skip_avx512_parallel82
	CMPQ AX, $5
	JE   skip_avx512_parallel82

	LOAD(0x78) // &in[5][0]
	LOAD(0x78)                            // &in[5][0]
	GALOIS(0xaa, 0xff, Z18, Z14, Z15, Z4)
	GALOIS(0xaa, 0xff, Z22, Z12, Z13, Z5)

    CMPQ AX, $6
    JE skip_avx512_parallel82
	CMPQ AX, $6
	JE   skip_avx512_parallel82

	LOAD(0x90) // &in[6][0]
	LOAD(0x90)                            // &in[6][0]
	GALOIS(0x00, 0x55, Z19, Z14, Z15, Z4)
	GALOIS(0x00, 0x55, Z23, Z12, Z13, Z5)

    CMPQ AX, $7
    JE skip_avx512_parallel82
	CMPQ AX, $7
	JE   skip_avx512_parallel82

	LOAD(0xa8) // &in[7][0]
	LOAD(0xa8)                            // &in[7][0]
	GALOIS(0xaa, 0xff, Z19, Z14, Z15, Z4)
	GALOIS(0xaa, 0xff, Z23, Z12, Z13, Z5)



@@ 115,8 205,8 @@ skip_avx512_parallel82:

	ADDQ $64, R11 // in4+=64

	ADDQ $64, DX  // out+=64
	ADDQ $64, CX  // out2+=64
	ADDQ $64, DX // out+=64
	ADDQ $64, CX // out2+=64

	SUBQ $1, R9
	JNZ  loopback_avx512_parallel82


@@ 130,13 220,13 @@ done_avx512_parallel82:
//
// func _galMulAVX512Parallel84(in, out [][]byte, matrix *[matrixSize84]byte, addTo bool)
TEXT ·_galMulAVX512Parallel84(SB), 7, $0
	MOVQ  in+0(FP), SI     //
	MOVQ  8(SI), R9        // R9: len(in)
	SHRQ  $6, R9           // len(in) / 64
	MOVQ  in+0(FP), SI
	MOVQ  8(SI), R9              // R9: len(in)
	SHRQ  $6, R9                 // len(in) / 64
	TESTQ R9, R9
	JZ    done_avx512_parallel84

	MOVQ matrix+48(FP), SI
	MOVQ      matrix+48(FP), SI
	VMOVDQU64 0x000(SI), Z16
	VMOVDQU64 0x040(SI), Z17
	VMOVDQU64 0x080(SI), Z18


@@ 157,17 247,17 @@ TEXT ·_galMulAVX512Parallel84(SB), 7, $0
	MOVQ         $15, BX
	VPBROADCASTB BX, Z2

	MOVB addTo+56(FP), AX
	MOVB  addTo+56(FP), AX
	IMULQ $-0x1, AX
	KMOVQ AX, K1
	MOVQ in+0(FP), SI  //  SI: &in
	MOVQ in_len+8(FP), AX  // number of inputs
	XORQ R11, R11
	MOVQ out+24(FP), DX
	MOVQ 24(DX), CX    //  CX: &out[1][0]
	MOVQ 48(DX), R10   // R10: &out[2][0]
	MOVQ 72(DX), R12   // R12: &out[3][0]
	MOVQ (DX), DX      //  DX: &out[0][0]
	MOVQ  in+0(FP), SI     // SI: &in
	MOVQ  in_len+8(FP), AX // number of inputs
	XORQ  R11, R11
	MOVQ  out+24(FP), DX
	MOVQ  24(DX), CX       // CX: &out[1][0]
	MOVQ  48(DX), R10      // R10: &out[2][0]
	MOVQ  72(DX), R12      // R12: &out[3][0]
	MOVQ  (DX), DX         // DX: &out[0][0]

loopback_avx512_parallel84:
	VMOVDQU64.Z (DX), K1, Z4


@@ 175,70 265,70 @@ loopback_avx512_parallel84:
	VMOVDQU64.Z (R10), K1, Z6
	VMOVDQU64.Z (R12), K1, Z7

	LOAD(0x00) // &in[0][0]
	LOAD(0x00)                            // &in[0][0]
	GALOIS(0x00, 0x55, Z16, Z14, Z15, Z4)
	GALOIS(0x00, 0x55, Z20, Z12, Z13, Z5)
	GALOIS(0x00, 0x55, Z24, Z10, Z11, Z6)
	GALOIS(0x00, 0x55, Z28,  Z8,  Z9, Z7)

	CMPQ AX, $1
	JE skip_avx512_parallel84
	JE   skip_avx512_parallel84

	LOAD(0x18) // &in[1][0]
	LOAD(0x18)                            // &in[1][0]
	GALOIS(0xaa, 0xff, Z16, Z14, Z15, Z4)
	GALOIS(0xaa, 0xff, Z20, Z12, Z13, Z5)
	GALOIS(0xaa, 0xff, Z24, Z10, Z11, Z6)
	GALOIS(0xaa, 0xff, Z28,  Z8,  Z9, Z7)

	CMPQ AX, $2
	JE skip_avx512_parallel84
	JE   skip_avx512_parallel84

	LOAD(0x30) // &in[2][0]
	LOAD(0x30)                            // &in[2][0]
	GALOIS(0x00, 0x55, Z17, Z14, Z15, Z4)
	GALOIS(0x00, 0x55, Z21, Z12, Z13, Z5)
	GALOIS(0x00, 0x55, Z25, Z10, Z11, Z6)
	GALOIS(0x00, 0x55, Z29,  Z8,  Z9, Z7)

	CMPQ AX, $3
	JE skip_avx512_parallel84
	JE   skip_avx512_parallel84

	LOAD(0x48) // &in[3][0]
	LOAD(0x48)                            // &in[3][0]
	GALOIS(0xaa, 0xff, Z17, Z14, Z15, Z4)
	GALOIS(0xaa, 0xff, Z21, Z12, Z13, Z5)
	GALOIS(0xaa, 0xff, Z25, Z10, Z11, Z6)
	GALOIS(0xaa, 0xff, Z29,  Z8,  Z9, Z7)

	CMPQ AX, $4
	JE skip_avx512_parallel84
	JE   skip_avx512_parallel84

	LOAD(0x60) // &in[4][0]
	LOAD(0x60)                            // &in[4][0]
	GALOIS(0x00, 0x55, Z18, Z14, Z15, Z4)
	GALOIS(0x00, 0x55, Z22, Z12, Z13, Z5)
	GALOIS(0x00, 0x55, Z26, Z10, Z11, Z6)
	GALOIS(0x00, 0x55, Z30,  Z8,  Z9, Z7)

	CMPQ AX, $5
	JE skip_avx512_parallel84
	JE   skip_avx512_parallel84

	LOAD(0x78) // &in[5][0]
	LOAD(0x78)                            // &in[5][0]
	GALOIS(0xaa, 0xff, Z18, Z14, Z15, Z4)
	GALOIS(0xaa, 0xff, Z22, Z12, Z13, Z5)
	GALOIS(0xaa, 0xff, Z26, Z10, Z11, Z6)
	GALOIS(0xaa, 0xff, Z30,  Z8,  Z9, Z7)

	CMPQ AX, $6
	JE skip_avx512_parallel84
	JE   skip_avx512_parallel84

	LOAD(0x90) // &in[6][0]
	LOAD(0x90)                            // &in[6][0]
	GALOIS(0x00, 0x55, Z19, Z14, Z15, Z4)
	GALOIS(0x00, 0x55, Z23, Z12, Z13, Z5)
	GALOIS(0x00, 0x55, Z27, Z10, Z11, Z6)
	GALOIS(0x00, 0x55, Z31,  Z8,  Z9, Z7)

	CMPQ AX, $7
	JE skip_avx512_parallel84
	JE   skip_avx512_parallel84

	LOAD(0xa8) // &in[7][0]
	LOAD(0xa8)                            // &in[7][0]
	GALOIS(0xaa, 0xff, Z19, Z14, Z15, Z4)
	GALOIS(0xaa, 0xff, Z23, Z12, Z13, Z5)
	GALOIS(0xaa, 0xff, Z27, Z10, Z11, Z6)

M vendor/github.com/klauspost/reedsolomon/galois_amd64.go => vendor/github.com/klauspost/reedsolomon/galois_amd64.go +65 -19
@@ 21,6 21,15 @@ func galMulAVX2(low, high, in, out []byte)
//go:noescape
func sSE2XorSlice(in, out []byte)

//go:noescape
func galMulAVX2Xor_64(low, high, in, out []byte)

//go:noescape
func galMulAVX2_64(low, high, in, out []byte)

//go:noescape
func sSE2XorSlice_64(in, out []byte)

// This is what the assembler routines do in blocks of 16 bytes:
/*
func galMulSSSE3(low, high, in, out []byte) {


@@ 40,17 49,33 @@ func galMulSSSE3Xor(low, high, in, out []byte) {
}
*/

// bigSwitchover is the size where 64 bytes are processed per loop.
const bigSwitchover = 128

func galMulSlice(c byte, in, out []byte, o *options) {
	var done int
	if c == 1 {
		copy(out, in)
		return
	}
	if o.useAVX2 {
		galMulAVX2(mulTableLow[c][:], mulTableHigh[c][:], in, out)
		done = (len(in) >> 5) << 5
		if len(in) >= bigSwitchover {
			galMulAVX2_64(mulTableLow[c][:], mulTableHigh[c][:], in, out)
			done := (len(in) >> 6) << 6
			in = in[done:]
			out = out[done:]
		}
		if len(in) > 32 {
			galMulAVX2(mulTableLow[c][:], mulTableHigh[c][:], in, out)
			done := (len(in) >> 5) << 5
			in = in[done:]
			out = out[done:]
		}
	} else if o.useSSSE3 {
		galMulSSSE3(mulTableLow[c][:], mulTableHigh[c][:], in, out)
		done = (len(in) >> 4) << 4
		done := (len(in) >> 4) << 4
		in = in[done:]
		out = out[done:]
	}
	in = in[done:]
	out = out[done:]
	out = out[:len(in)]
	mt := mulTable[c][:256]
	for i := range in {


@@ 59,16 84,30 @@ func galMulSlice(c byte, in, out []byte, o *options) {
}

func galMulSliceXor(c byte, in, out []byte, o *options) {
	var done int
	if c == 1 {
		sliceXor(in, out, o)
		return
	}

	if o.useAVX2 {
		galMulAVX2Xor(mulTableLow[c][:], mulTableHigh[c][:], in, out)
		done = (len(in) >> 5) << 5
		if len(in) >= bigSwitchover {
			galMulAVX2Xor_64(mulTableLow[c][:], mulTableHigh[c][:], in, out)
			done := (len(in) >> 6) << 6
			in = in[done:]
			out = out[done:]
		}
		if len(in) >= 32 {
			galMulAVX2Xor(mulTableLow[c][:], mulTableHigh[c][:], in, out)
			done := (len(in) >> 5) << 5
			in = in[done:]
			out = out[done:]
		}
	} else if o.useSSSE3 {
		galMulSSSE3Xor(mulTableLow[c][:], mulTableHigh[c][:], in, out)
		done = (len(in) >> 4) << 4
		done := (len(in) >> 4) << 4
		in = in[done:]
		out = out[done:]
	}
	in = in[done:]
	out = out[done:]
	out = out[:len(in)]
	mt := mulTable[c][:256]
	for i := range in {


@@ 77,14 116,21 @@ func galMulSliceXor(c byte, in, out []byte, o *options) {
}

// slice galois add
func sliceXor(in, out []byte, sse2 bool) {
	var done int
	if sse2 {
		sSE2XorSlice(in, out)
		done = (len(in) >> 4) << 4
func sliceXor(in, out []byte, o *options) {
	if o.useSSE2 {
		if len(in) >= bigSwitchover {
			sSE2XorSlice_64(in, out)
			done := (len(in) >> 6) << 6
			in = in[done:]
			out = out[done:]
		}
		if len(in) >= 16 {
			sSE2XorSlice(in, out)
			done := (len(in) >> 4) << 4
			in = in[done:]
			out = out[done:]
		}
	}
	in = in[done:]
	out = out[done:]
	out = out[:len(in)]
	for i := range in {
		out[i] ^= in[i]

M vendor/github.com/klauspost/reedsolomon/galois_amd64.s => vendor/github.com/klauspost/reedsolomon/galois_amd64.s +132 -0
@@ 234,3 234,135 @@ loopback_xor_sse2:

done_xor_sse2:
	RET

// func galMulAVX2Xor_64(low, high, in, out []byte)
TEXT ·galMulAVX2Xor_64(SB), 7, $0
	MOVQ  low+0(FP), SI     // SI: &low
	MOVQ  high+24(FP), DX   // DX: &high
	MOVQ  $15, BX           // BX: low mask
	MOVQ  BX, X5
	MOVOU (SI), X6          // X6: low
	MOVOU (DX), X7          // X7: high
	MOVQ  in_len+56(FP), R9 // R9: len(in)

	VINSERTI128  $1, X6, Y6, Y6 // low
	VINSERTI128  $1, X7, Y7, Y7 // high
	VPBROADCASTB X5, Y8         // Y8: lomask (unpacked)

	SHRQ  $6, R9           // len(in) / 64
	MOVQ  out+72(FP), DX   // DX: &out
	MOVQ  in+48(FP), SI    // SI: &in
	TESTQ R9, R9
	JZ    done_xor_avx2_64

loopback_xor_avx2_64:
	VMOVDQU (SI), Y0
	VMOVDQU 32(SI), Y10
	VMOVDQU (DX), Y4
	VMOVDQU 32(DX), Y14
	VPSRLQ  $4, Y0, Y1    // Y1: high input
	VPSRLQ  $4, Y10, Y11  // Y11: high input 2
	VPAND   Y8, Y0, Y0    // Y0: low input
	VPAND   Y8, Y10, Y10  // Y10: low input 2
	VPAND   Y8, Y1, Y1    // Y11: high input
	VPAND   Y8, Y11, Y11  // Y11: high input 2
	VPSHUFB Y0, Y6, Y2    // Y2: mul low part
	VPSHUFB Y10, Y6, Y12  // Y12: mul low part 2
	VPSHUFB Y1, Y7, Y3    // Y3: mul high part
	VPSHUFB Y11, Y7, Y13  // Y13: mul high part 2
	VPXOR   Y3, Y2, Y3    // Y3: Result
	VPXOR   Y13, Y12, Y13 // Y13: Result 2
	VPXOR   Y4, Y3, Y4    // Y4: Result
	VPXOR   Y14, Y13, Y14 // Y4: Result 2
	VMOVDQU Y4, (DX)
	VMOVDQU Y14, 32(DX)

	ADDQ $64, SI              // in+=64
	ADDQ $64, DX              // out+=64
	SUBQ $1, R9
	JNZ  loopback_xor_avx2_64

done_xor_avx2_64:
	VZEROUPPER
	RET

// func galMulAVX2_64(low, high, in, out []byte)
TEXT ·galMulAVX2_64(SB), 7, $0
	MOVQ  low+0(FP), SI     // SI: &low
	MOVQ  high+24(FP), DX   // DX: &high
	MOVQ  $15, BX           // BX: low mask
	MOVQ  BX, X5
	MOVOU (SI), X6          // X6: low
	MOVOU (DX), X7          // X7: high
	MOVQ  in_len+56(FP), R9 // R9: len(in)

	VINSERTI128  $1, X6, Y6, Y6 // low
	VINSERTI128  $1, X7, Y7, Y7 // high
	VPBROADCASTB X5, Y8         // Y8: lomask (unpacked)

	SHRQ  $6, R9         // len(in) / 64
	MOVQ  out+72(FP), DX // DX: &out
	MOVQ  in+48(FP), SI  // SI: &in
	TESTQ R9, R9
	JZ    done_avx2_64

loopback_avx2_64:
	VMOVDQU (SI), Y0
	VMOVDQU 32(SI), Y10
	VPSRLQ  $4, Y0, Y1    // Y1: high input
	VPSRLQ  $4, Y10, Y11  // Y11: high input 2
	VPAND   Y8, Y0, Y0    // Y0: low input
	VPAND   Y8, Y10, Y10  // Y10: low input
	VPAND   Y8, Y1, Y1    // Y1: high input
	VPAND   Y8, Y11, Y11  // Y11: high input 2
	VPSHUFB Y0, Y6, Y2    // Y2: mul low part
	VPSHUFB Y10, Y6, Y12  // Y12: mul low part 2
	VPSHUFB Y1, Y7, Y3    // Y3: mul high part
	VPSHUFB Y11, Y7, Y13  // Y13: mul high part 2
	VPXOR   Y3, Y2, Y4    // Y4: Result
	VPXOR   Y13, Y12, Y14 // Y14: Result 2
	VMOVDQU Y4, (DX)
	VMOVDQU Y14, 32(DX)

	ADDQ $64, SI          // in+=64
	ADDQ $64, DX          // out+=64
	SUBQ $1, R9
	JNZ  loopback_avx2_64

done_avx2_64:
	VZEROUPPER
	RET

// func sSE2XorSlice_64(in, out []byte)
TEXT ·sSE2XorSlice_64(SB), 7, $0
	MOVQ in+0(FP), SI     // SI: &in
	MOVQ in_len+8(FP), R9 // R9: len(in)
	MOVQ out+24(FP), DX   // DX: &out
	SHRQ $6, R9           // len(in) / 64
	CMPQ R9, $0
	JEQ  done_xor_sse2_64

loopback_xor_sse2_64:
	MOVOU (SI), X0             // in[x]
	MOVOU 16(SI), X2           // in[x]
	MOVOU 32(SI), X4           // in[x]
	MOVOU 48(SI), X6           // in[x]
	MOVOU (DX), X1             // out[x]
	MOVOU 16(DX), X3           // out[x]
	MOVOU 32(DX), X5           // out[x]
	MOVOU 48(DX), X7           // out[x]
	PXOR  X0, X1
	PXOR  X2, X3
	PXOR  X4, X5
	PXOR  X6, X7
	MOVOU X1, (DX)
	MOVOU X3, 16(DX)
	MOVOU X5, 32(DX)
	MOVOU X7, 48(DX)
	ADDQ  $64, SI              // in+=64
	ADDQ  $64, DX              // out+=64
	SUBQ  $1, R9
	JNZ   loopback_xor_sse2_64

done_xor_sse2_64:
	RET

M vendor/github.com/klauspost/reedsolomon/galois_arm64.go => vendor/github.com/klauspost/reedsolomon/galois_arm64.go +9 -1
@@ 14,6 14,10 @@ func galMulNEON(c uint64, in, out []byte)
func galMulXorNEON(c uint64, in, out []byte)

func galMulSlice(c byte, in, out []byte, o *options) {
	if c == 1 {
		copy(out, in)
		return
	}
	var done int
	galMulNEON(uint64(c), in, out)
	done = (len(in) >> 5) << 5


@@ 28,6 32,10 @@ func galMulSlice(c byte, in, out []byte, o *options) {
}

func galMulSliceXor(c byte, in, out []byte, o *options) {
	if c == 1 {
		sliceXor(in, out, o)
		return
	}
	var done int
	galMulXorNEON(uint64(c), in, out)
	done = (len(in) >> 5) << 5


@@ 42,7 50,7 @@ func galMulSliceXor(c byte, in, out []byte, o *options) {
}

// slice galois add
func sliceXor(in, out []byte, sse2 bool) {
func sliceXor(in, out []byte, o *options) {
	for n, input := range in {
		out[n] ^= input
	}

M vendor/github.com/klauspost/reedsolomon/galois_noasm.go => vendor/github.com/klauspost/reedsolomon/galois_noasm.go +13 -3
@@ 7,23 7,33 @@
package reedsolomon

func galMulSlice(c byte, in, out []byte, o *options) {
	mt := mulTable[c][:256]
	out = out[:len(in)]
	if c == 1 {
		copy(out, in)
		return
	}
	mt := mulTable[c][:256]
	for n, input := range in {
		out[n] = mt[input]
	}
}

func galMulSliceXor(c byte, in, out []byte, o *options) {
	mt := mulTable[c][:256]
	out = out[:len(in)]
	if c == 1 {
		for n, input := range in {
			out[n] ^= input
		}
		return
	}
	mt := mulTable[c][:256]
	for n, input := range in {
		out[n] ^= mt[input]
	}
}

// slice galois add
func sliceXor(in, out []byte, sse2 bool) {
func sliceXor(in, out []byte, o *options) {
	for n, input := range in {
		out[n] ^= input
	}

M vendor/github.com/klauspost/reedsolomon/galois_ppc64le.go => vendor/github.com/klauspost/reedsolomon/galois_ppc64le.go +9 -1
@@ 32,6 32,10 @@ func galMulPpcXor(low, high, in, out []byte) {
*/

func galMulSlice(c byte, in, out []byte, o *options) {
	if c == 1 {
		copy(out, in)
		return
	}
	done := (len(in) >> 4) << 4
	if done > 0 {
		galMulPpc(mulTableLow[c][:], mulTableHigh[c][:], in[:done], out)


@@ 46,6 50,10 @@ func galMulSlice(c byte, in, out []byte, o *options) {
}

func galMulSliceXor(c byte, in, out []byte, o *options) {
	if c == 1 {
		sliceXor(in, out, o)
		return
	}
	done := (len(in) >> 4) << 4
	if done > 0 {
		galMulPpcXor(mulTableLow[c][:], mulTableHigh[c][:], in[:done], out)


@@ 60,7 68,7 @@ func galMulSliceXor(c byte, in, out []byte, o *options) {
}

// slice galois add
func sliceXor(in, out []byte, sse2 bool) {
func sliceXor(in, out []byte, o *options) {
	for n, input := range in {
		out[n] ^= input
	}

M vendor/github.com/klauspost/reedsolomon/galois_ppc64le.s => vendor/github.com/klauspost/reedsolomon/galois_ppc64le.s +56 -58
@@ 32,89 32,87 @@
#define FLIP      VS41
#define FLIP_     V9


// func galMulPpc(low, high, in, out []byte)
TEXT ·galMulPpc(SB), NOFRAME|NOSPLIT, $0-96
    MOVD    low+0(FP), LOW
    MOVD    high+24(FP), HIGH
    MOVD    in+48(FP), IN
    MOVD    in_len+56(FP), LEN
    MOVD    out+72(FP), OUT
	MOVD low+0(FP), LOW
	MOVD high+24(FP), HIGH
	MOVD in+48(FP), IN
	MOVD in_len+56(FP), LEN
	MOVD out+72(FP), OUT

    MOVD    $16, OFFSET1
    MOVD    $32, OFFSET2
	MOVD $16, OFFSET1
	MOVD $32, OFFSET2

    MOVD    $·constants(SB), CONSTANTS
    LXVD2X  (CONSTANTS)(R0), ROTATE
    LXVD2X  (CONSTANTS)(OFFSET1), MASK
    LXVD2X  (CONSTANTS)(OFFSET2), FLIP
	MOVD   $·constants(SB), CONSTANTS
	LXVD2X (CONSTANTS)(R0), ROTATE
	LXVD2X (CONSTANTS)(OFFSET1), MASK
	LXVD2X (CONSTANTS)(OFFSET2), FLIP

    LXVD2X  (LOW)(R0), X6
    LXVD2X  (HIGH)(R0), X7
    VPERM   X6_, V31, FLIP_, X6_
    VPERM   X7_, V31, FLIP_, X7_
	LXVD2X (LOW)(R0), X6
	LXVD2X (HIGH)(R0), X7
	VPERM  X6_, V31, FLIP_, X6_
	VPERM  X7_, V31, FLIP_, X7_

    MOVD    $0, OFFSET
	MOVD $0, OFFSET

loop:
    LXVD2X  (IN)(OFFSET), MSG

    VSRB    MSG_, ROTATE_, MSG_HI_
    VAND    MSG_, MASK_, MSG_
    VPERM   X6_, V31, MSG_, MSG_
    VPERM   X7_, V31, MSG_HI_, MSG_HI_
	LXVD2X (IN)(OFFSET), MSG

    VXOR    MSG_, MSG_HI_, MSG_
	VSRB  MSG_, ROTATE_, MSG_HI_
	VAND  MSG_, MASK_, MSG_
	VPERM X6_, V31, MSG_, MSG_
	VPERM X7_, V31, MSG_HI_, MSG_HI_

    STXVD2X MSG, (OUT)(OFFSET)
	VXOR MSG_, MSG_HI_, MSG_

    ADD     $16, OFFSET, OFFSET
    CMP     LEN, OFFSET
    BGT     loop
    RET
	STXVD2X MSG, (OUT)(OFFSET)

	ADD $16, OFFSET, OFFSET
	CMP LEN, OFFSET
	BGT loop
	RET

// func galMulPpcXorlow, high, in, out []byte)
TEXT ·galMulPpcXor(SB), NOFRAME|NOSPLIT, $0-96
    MOVD    low+0(FP), LOW
    MOVD    high+24(FP), HIGH
    MOVD    in+48(FP), IN
    MOVD    in_len+56(FP), LEN
    MOVD    out+72(FP), OUT
	MOVD low+0(FP), LOW
	MOVD high+24(FP), HIGH
	MOVD in+48(FP), IN
	MOVD in_len+56(FP), LEN
	MOVD out+72(FP), OUT

    MOVD    $16, OFFSET1
    MOVD    $32, OFFSET2
	MOVD $16, OFFSET1
	MOVD $32, OFFSET2

    MOVD    $·constants(SB), CONSTANTS
    LXVD2X  (CONSTANTS)(R0), ROTATE
    LXVD2X  (CONSTANTS)(OFFSET1), MASK
    LXVD2X  (CONSTANTS)(OFFSET2), FLIP
	MOVD   $·constants(SB), CONSTANTS
	LXVD2X (CONSTANTS)(R0), ROTATE
	LXVD2X (CONSTANTS)(OFFSET1), MASK
	LXVD2X (CONSTANTS)(OFFSET2), FLIP

    LXVD2X  (LOW)(R0), X6
    LXVD2X  (HIGH)(R0), X7
    VPERM   X6_, V31, FLIP_, X6_
    VPERM   X7_, V31, FLIP_, X7_
	LXVD2X (LOW)(R0), X6
	LXVD2X (HIGH)(R0), X7
	VPERM  X6_, V31, FLIP_, X6_
	VPERM  X7_, V31, FLIP_, X7_

    MOVD    $0, OFFSET
	MOVD $0, OFFSET

loopXor:
    LXVD2X  (IN)(OFFSET), MSG
    LXVD2X  (OUT)(OFFSET), RESULT
	LXVD2X (IN)(OFFSET), MSG
	LXVD2X (OUT)(OFFSET), RESULT

    VSRB    MSG_, ROTATE_, MSG_HI_
    VAND    MSG_, MASK_, MSG_
    VPERM   X6_, V31, MSG_, MSG_
    VPERM   X7_, V31, MSG_HI_, MSG_HI_
	VSRB  MSG_, ROTATE_, MSG_HI_
	VAND  MSG_, MASK_, MSG_
	VPERM X6_, V31, MSG_, MSG_
	VPERM X7_, V31, MSG_HI_, MSG_HI_

    VXOR    MSG_, MSG_HI_, MSG_
    VXOR    MSG_, RESULT_, RESULT_
	VXOR MSG_, MSG_HI_, MSG_
	VXOR MSG_, RESULT_, RESULT_

    STXVD2X RESULT, (OUT)(OFFSET)
	STXVD2X RESULT, (OUT)(OFFSET)

    ADD     $16, OFFSET, OFFSET
    CMP     LEN, OFFSET
    BGT     loopXor
    RET
	ADD $16, OFFSET, OFFSET
	CMP LEN, OFFSET
	BGT loopXor
	RET

DATA ·constants+0x0(SB)/8, $0x0404040404040404
DATA ·constants+0x8(SB)/8, $0x0404040404040404

M vendor/github.com/klauspost/reedsolomon/options.go => vendor/github.com/klauspost/reedsolomon/options.go +42 -0
@@ 17,6 17,11 @@ type options struct {
	useCauchy                             bool
	shardSize                             int
	perRound                              int

	// stream options
	concReads  bool
	concWrites bool
	streamBS   int
}

var defaultOptions = options{


@@ 74,6 79,43 @@ func WithMinSplitSize(n int) Option {
	}
}

// WithConcurrentStreams will enable concurrent reads and writes on the streams.
// Default: Disabled, meaning only one stream will be read/written at the time.
// Ignored if not used on a stream input.
func WithConcurrentStreams(enabled bool) Option {
	return func(o *options) {
		o.concReads, o.concWrites = enabled, enabled
	}
}

// WithConcurrentStreamReads will enable concurrent reads from the input streams.
// Default: Disabled, meaning only one stream will be read at the time.
// Ignored if not used on a stream input.
func WithConcurrentStreamReads(enabled bool) Option {
	return func(o *options) {
		o.concReads = enabled
	}
}

// WithConcurrentStreamWrites will enable concurrent writes to the the output streams.
// Default: Disabled, meaning only one stream will be written at the time.
// Ignored if not used on a stream input.
func WithConcurrentStreamWrites(enabled bool) Option {
	return func(o *options) {
		o.concWrites = enabled
	}
}

// WithStreamBlockSize allows to set a custom block size per round of reads/writes.
// If not set, any shard size set with WithAutoGoroutines will be used.
// If WithAutoGoroutines is also unset, 4MB will be used.
// Ignored if not used on stream.
func WithStreamBlockSize(n int) Option {
	return func(o *options) {
		o.streamBS = n
	}
}

func withSSSE3(enabled bool) Option {
	return func(o *options) {
		o.useSSSE3 = enabled

M vendor/github.com/klauspost/reedsolomon/reedsolomon.go => vendor/github.com/klauspost/reedsolomon/reedsolomon.go +32 -25
@@ 259,25 259,6 @@ func New(dataShards, parityShards int, opts ...Option) (Encoder, error) {
	// Align to 64 bytes.
	r.o.perRound = ((r.o.perRound + 63) / 64) * 64

	if r.o.perRound < r.o.minSplitSize {
		r.o.perRound = r.o.minSplitSize
	}

	if r.o.shardSize > 0 {
		p := runtime.NumCPU()
		g := r.o.shardSize / r.o.perRound

		if g < p {
			g = p
		}

		// Have g be multiple of p
		g += p - 1
		g -= g % p

		r.o.maxGoroutines = g
	}

	if r.o.minSplitSize <= 0 {
		// Set minsplit as high as we can, but still have parity in L1.
		cacheSize := cpuid.CPU.Cache.L1D


@@ 292,6 273,32 @@ func New(dataShards, parityShards int, opts ...Option) (Encoder, error) {
		}
	}

	if r.o.perRound < r.o.minSplitSize {
		r.o.perRound = r.o.minSplitSize
	}

	if r.o.shardSize > 0 {
		p := runtime.GOMAXPROCS(0)
		if p == 1 || r.o.shardSize <= r.o.minSplitSize*2 {
			// Not worth it.
			r.o.maxGoroutines = 1
		} else {
			g := r.o.shardSize / r.o.perRound

			// Overprovision by a factor of 2.
			if g < p*2 && r.o.perRound > r.o.minSplitSize*2 {
				g = p * 2
				r.o.perRound /= 2
			}

			// Have g be multiple of p
			g += p - 1
			g -= g % p

			r.o.maxGoroutines = g
		}
	}

	// Inverted matrices are cached in a tree keyed by the indices
	// of the invalid rows of the data to reconstruct.
	// The inversion root node will have the identity matrix as


@@ 392,7 399,7 @@ func (r reedSolomon) updateParityShards(matrixRows, oldinputs, newinputs, output
		}
		oldin := oldinputs[c]
		// oldinputs data will be change
		sliceXor(in, oldin, r.o.useSSE2)
		sliceXor(in, oldin, &r.o)
		for iRow := 0; iRow < outputCount; iRow++ {
			galMulSliceXor(matrixRows[iRow][c], oldin, outputs[iRow], &r.o)
		}


@@ 419,7 426,7 @@ func (r reedSolomon) updateParityShardsP(matrixRows, oldinputs, newinputs, outpu
				}
				oldin := oldinputs[c]
				// oldinputs data will be change
				sliceXor(in[start:stop], oldin[start:stop], r.o.useSSE2)
				sliceXor(in[start:stop], oldin[start:stop], &r.o)
				for iRow := 0; iRow < outputCount; iRow++ {
					galMulSliceXor(matrixRows[iRow][c], oldin[start:stop], outputs[iRow][start:stop], &r.o)
				}


@@ 503,8 510,8 @@ func (r reedSolomon) codeSomeShardsP(matrixRows, inputs, outputs [][]byte, outpu
	if do < r.o.minSplitSize {
		do = r.o.minSplitSize
	}
	// Make sizes divisible by 32
	do = (do + 31) & (^31)
	// Make sizes divisible by 64
	do = (do + 63) & (^63)
	start := 0
	for start < byteCount {
		if start+do > byteCount {


@@ 576,8 583,8 @@ func (r reedSolomon) checkSomeShardsP(matrixRows, inputs, toCheck [][]byte, outp
	if do < r.o.minSplitSize {
		do = r.o.minSplitSize
	}
	// Make sizes divisible by 32
	do = (do + 31) & (^31)
	// Make sizes divisible by 64
	do = (do + 63) & (^63)
	start := 0
	for start < byteCount {
		if start+do > byteCount {

M vendor/github.com/klauspost/reedsolomon/streaming.go => vendor/github.com/klauspost/reedsolomon/streaming.go +55 -34
@@ 131,12 131,15 @@ func (s StreamWriteError) String() string {
// distribution of datashards and parity shards.
// Construct if using NewStream()
type rsStream struct {
	r  *reedSolomon
	bs int // Block size
	r *reedSolomon
	o options

	// Shard reader
	readShards func(dst [][]byte, in []io.Reader) error
	// Shard writer
	writeShards func(out []io.Writer, in [][]byte) error

	blockPool sync.Pool
}

// NewStream creates a new encoder and initializes it to


@@ 144,14 147,43 @@ type rsStream struct {
// you want to use. You can reuse this encoder.
// Note that the maximum number of data shards is 256.
func NewStream(dataShards, parityShards int, o ...Option) (StreamEncoder, error) {
	r := rsStream{o: defaultOptions}
	for _, opt := range o {
		opt(&r.o)
	}
	// Override block size if shard size is set.
	if r.o.streamBS == 0 && r.o.shardSize > 0 {
		r.o.streamBS = r.o.shardSize
	}
	if r.o.streamBS <= 0 {
		r.o.streamBS = 4 << 20
	}
	if r.o.shardSize == 0 && r.o.maxGoroutines == defaultOptions.maxGoroutines {
		o = append(o, WithAutoGoroutines(r.o.streamBS))
	}

	enc, err := New(dataShards, parityShards, o...)
	if err != nil {
		return nil, err
	}
	rs := enc.(*reedSolomon)
	r := rsStream{r: rs, bs: 4 << 20}
	r.r = enc.(*reedSolomon)

	r.blockPool.New = func() interface{} {
		out := make([][]byte, dataShards+parityShards)
		for i := range out {
			out[i] = make([]byte, r.o.streamBS)
		}
		return out
	}
	r.readShards = readShards
	r.writeShards = writeShards
	if r.o.concReads {
		r.readShards = cReadShards
	}
	if r.o.concWrites {
		r.writeShards = cWriteShards
	}

	return &r, err
}



@@ 160,27 192,13 @@ func NewStream(dataShards, parityShards int, o ...Option) (StreamEncoder, error)
//
// This functions as 'NewStream', but allows you to enable CONCURRENT reads and writes.
func NewStreamC(dataShards, parityShards int, conReads, conWrites bool, o ...Option) (StreamEncoder, error) {
	enc, err := New(dataShards, parityShards, o...)
	if err != nil {
		return nil, err
	}
	rs := enc.(*reedSolomon)
	r := rsStream{r: rs, bs: 4 << 20}
	r.readShards = readShards
	r.writeShards = writeShards
	if conReads {
		r.readShards = cReadShards
	}
	if conWrites {
		r.writeShards = cWriteShards
	}
	return &r, err
	return NewStream(dataShards, parityShards, append(o, WithConcurrentStreamReads(conReads), WithConcurrentStreamWrites(conWrites))...)
}

func createSlice(n, length int) [][]byte {
	out := make([][]byte, n)
func (r *rsStream) createSlice() [][]byte {
	out := r.blockPool.Get().([][]byte)
	for i := range out {
		out[i] = make([]byte, length)
		out[i] = out[i][:r.o.streamBS]
	}
	return out
}


@@ 200,7 218,7 @@ func createSlice(n, length int) [][]byte {
// If a data stream returns an error, a StreamReadError type error
// will be returned. If a parity writer returns an error, a
// StreamWriteError will be returned.
func (r rsStream) Encode(data []io.Reader, parity []io.Writer) error {
func (r *rsStream) Encode(data []io.Reader, parity []io.Writer) error {
	if len(data) != r.r.DataShards {
		return ErrTooFewShards
	}


@@ 209,7 227,8 @@ func (r rsStream) Encode(data []io.Reader, parity []io.Writer) error {
		return ErrTooFewShards
	}

	all := createSlice(r.r.Shards, r.bs)
	all := r.createSlice()
	defer r.blockPool.Put(all)
	in := all[:r.r.DataShards]
	out := all[r.r.DataShards:]
	read := 0


@@ 242,11 261,11 @@ func (r rsStream) Encode(data []io.Reader, parity []io.Writer) error {
// Trim the shards so they are all the same size
func trimShards(in [][]byte, size int) [][]byte {
	for i := range in {
		if in[i] != nil {
		if len(in[i]) != 0 {
			in[i] = in[i][0:size]
		}
		if len(in[i]) < size {
			in[i] = nil
			in[i] = in[i][:0]
		}
	}
	return in


@@ 259,7 278,7 @@ func readShards(dst [][]byte, in []io.Reader) error {
	size := -1
	for i := range in {
		if in[i] == nil {
			dst[i] = nil
			dst[i] = dst[i][:0]
			continue
		}
		n, err := io.ReadFull(in[i], dst[i])


@@ 323,7 342,7 @@ func cReadShards(dst [][]byte, in []io.Reader) error {
	res := make(chan readResult, len(in))
	for i := range in {
		if in[i] == nil {
			dst[i] = nil
			dst[i] = dst[i][:0]
			wg.Done()
			continue
		}


@@ 405,13 424,14 @@ func cWriteShards(out []io.Writer, in [][]byte) error {
// Each reader must supply the same number of bytes.
// If a shard stream returns an error, a StreamReadError type error
// will be returned.
func (r rsStream) Verify(shards []io.Reader) (bool, error) {
func (r *rsStream) Verify(shards []io.Reader) (bool, error) {
	if len(shards) != r.r.Shards {
		return false, ErrTooFewShards
	}

	read := 0
	all := createSlice(r.r.Shards, r.bs)
	all := r.createSlice()
	defer r.blockPool.Put(all)
	for {
		err := r.readShards(all, shards)
		if err == io.EOF {


@@ 451,7 471,7 @@ var ErrReconstructMismatch = errors.New("valid shards and fill shards are mutual
// The reconstructed shard set is complete when explicitly asked for all missing shards.
// However its integrity is not automatically verified.
// Use the Verify function to check in case the data set is complete.
func (r rsStream) Reconstruct(valid []io.Reader, fill []io.Writer) error {
func (r *rsStream) Reconstruct(valid []io.Reader, fill []io.Writer) error {
	if len(valid) != r.r.Shards {
		return ErrTooFewShards
	}


@@ 459,7 479,8 @@ func (r rsStream) Reconstruct(valid []io.Reader, fill []io.Writer) error {
		return ErrTooFewShards
	}

	all := createSlice(r.r.Shards, r.bs)
	all := r.createSlice()
	defer r.blockPool.Put(all)
	reconDataOnly := true
	for i := range valid {
		if valid[i] != nil && fill[i] != nil {


@@ 507,7 528,7 @@ func (r rsStream) Reconstruct(valid []io.Reader, fill []io.Writer) error {
// You must supply the exact output size you want.
// If there are to few shards given, ErrTooFewShards will be returned.
// If the total data size is less than outSize, ErrShortData will be returned.
func (r rsStream) Join(dst io.Writer, shards []io.Reader, outSize int64) error {
func (r *rsStream) Join(dst io.Writer, shards []io.Reader, outSize int64) error {
	// Do we have enough shards?
	if len(shards) < r.r.DataShards {
		return ErrTooFewShards


@@ 546,7 567,7 @@ func (r rsStream) Join(dst io.Writer, shards []io.Reader, outSize int64) error {
// You must supply the total size of your input.
// 'ErrShortData' will be returned if it is unable to retrieve the
// number of bytes indicated.
func (r rsStream) Split(data io.Reader, dst []io.Writer, size int64) error {
func (r *rsStream) Split(data io.Reader, dst []io.Writer, size int64) error {
	if size == 0 {
		return ErrShortData
	}

M vendor/golang.org/x/sys/unix/syscall_darwin.go => vendor/golang.org/x/sys/unix/syscall_darwin.go +1 -0
@@ 423,6 423,7 @@ func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
//sysnb	Getrlimit(which int, lim *Rlimit) (err error)
//sysnb	Getrusage(who int, rusage *Rusage) (err error)
//sysnb	Getsid(pid int) (sid int, err error)
//sysnb	Gettimeofday(tp *Timeval) (err error)
//sysnb	Getuid() (uid int)
//sysnb	Issetugid() (tainted bool)
//sys	Kqueue() (fd int, err error)

M vendor/golang.org/x/sys/unix/syscall_darwin_386.go => vendor/golang.org/x/sys/unix/syscall_darwin_386.go +0 -11
@@ 20,17 20,6 @@ func setTimeval(sec, usec int64) Timeval {
	return Timeval{Sec: int32(sec), Usec: int32(usec)}
}

//sysnb	gettimeofday(tp *Timeval) (sec int32, usec int32, err error)
func Gettimeofday(tv *Timeval) (err error) {
	// The tv passed to gettimeofday must be non-nil
	// but is otherwise unused. The answers come back
	// in the two registers.
	sec, usec, err := gettimeofday(tv)
	tv.Sec = int32(sec)
	tv.Usec = int32(usec)
	return err
}

func SetKevent(k *Kevent_t, fd, mode, flags int) {
	k.Ident = uint32(fd)
	k.Filter = int16(mode)

M vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go => vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go +0 -11
@@ 20,17 20,6 @@ func setTimeval(sec, usec int64) Timeval {
	return Timeval{Sec: sec, Usec: int32(usec)}
}

//sysnb	gettimeofday(tp *Timeval) (sec int64, usec int32, err error)
func Gettimeofday(tv *Timeval) (err error) {
	// The tv passed to gettimeofday must be non-nil
	// but is otherwise unused. The answers come back
	// in the two registers.
	sec, usec, err := gettimeofday(tv)
	tv.Sec = sec
	tv.Usec = usec
	return err
}

func SetKevent(k *Kevent_t, fd, mode, flags int) {
	k.Ident = uint64(fd)
	k.Filter = int16(mode)

M vendor/golang.org/x/sys/unix/syscall_darwin_arm.go => vendor/golang.org/x/sys/unix/syscall_darwin_arm.go +0 -11
@@ 20,17 20,6 @@ func setTimeval(sec, usec int64) Timeval {
	return Timeval{Sec: int32(sec), Usec: int32(usec)}
}

//sysnb	gettimeofday(tp *Timeval) (sec int32, usec int32, err error)
func Gettimeofday(tv *Timeval) (err error) {
	// The tv passed to gettimeofday must be non-nil
	// but is otherwise unused. The answers come back
	// in the two registers.
	sec, usec, err := gettimeofday(tv)
	tv.Sec = int32(sec)
	tv.Usec = int32(usec)
	return err
}

func SetKevent(k *Kevent_t, fd, mode, flags int) {
	k.Ident = uint32(fd)
	k.Filter = int16(mode)

M vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go => vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go +0 -11
@@ 22,17 22,6 @@ func setTimeval(sec, usec int64) Timeval {
	return Timeval{Sec: sec, Usec: int32(usec)}
}

//sysnb	gettimeofday(tp *Timeval) (sec int64, usec int32, err error)
func Gettimeofday(tv *Timeval) (err error) {
	// The tv passed to gettimeofday must be non-nil
	// but is otherwise unused. The answers come back
	// in the two registers.
	sec, usec, err := gettimeofday(tv)
	tv.Sec = sec
	tv.Usec = usec
	return err
}

func SetKevent(k *Kevent_t, fd, mode, flags int) {
	k.Ident = uint64(fd)
	k.Filter = int16(mode)

M vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_11.go => vendor/golang.org/x/sys/unix/zsyscall_darwin_386.1_11.go +10 -12
@@ 966,6 966,16 @@ func Getsid(pid int) (sid int, err error) {

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Gettimeofday(tp *Timeval) (err error) {
	_, _, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Getuid() (uid int) {
	r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
	uid = int(r0)


@@ 1709,18 1719,6 @@ func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func gettimeofday(tp *Timeval) (sec int32, usec int32, err error) {
	r0, r1, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	sec = int32(r0)
	usec = int32(r1)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Fstat(fd int, stat *Stat_t) (err error) {
	_, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	if e1 != 0 {

M vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go => vendor/golang.org/x/sys/unix/zsyscall_darwin_386.go +15 -17
@@ 1376,6 1376,21 @@ func libc_getsid_trampoline()

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Gettimeofday(tp *Timeval) (err error) {
	_, _, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

func libc_gettimeofday_trampoline()

//go:linkname libc_gettimeofday libc_gettimeofday
//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Getuid() (uid int) {
	r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
	uid = int(r0)


@@ 2357,23 2372,6 @@ func libc_ptrace_trampoline()

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func gettimeofday(tp *Timeval) (sec int32, usec int32, err error) {
	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
	sec = int32(r0)
	usec = int32(r1)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

func libc_gettimeofday_trampoline()

//go:linkname libc_gettimeofday libc_gettimeofday
//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Fstat(fd int, stat *Stat_t) (err error) {
	_, _, e1 := syscall_syscall(funcPC(libc_fstat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	if e1 != 0 {

M vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_11.go => vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.1_11.go +10 -12
@@ 966,6 966,16 @@ func Getsid(pid int) (sid int, err error) {

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Gettimeofday(tp *Timeval) (err error) {
	_, _, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Getuid() (uid int) {
	r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
	uid = int(r0)


@@ 1709,18 1719,6 @@ func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func gettimeofday(tp *Timeval) (sec int64, usec int32, err error) {
	r0, r1, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	sec = int64(r0)
	usec = int32(r1)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Fstat(fd int, stat *Stat_t) (err error) {
	_, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	if e1 != 0 {

M vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go => vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go +15 -17
@@ 1376,6 1376,21 @@ func libc_getsid_trampoline()

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Gettimeofday(tp *Timeval) (err error) {
	_, _, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

func libc_gettimeofday_trampoline()

//go:linkname libc_gettimeofday libc_gettimeofday
//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Getuid() (uid int) {
	r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
	uid = int(r0)


@@ 2357,23 2372,6 @@ func libc_ptrace_trampoline()

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func gettimeofday(tp *Timeval) (sec int64, usec int32, err error) {
	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
	sec = int64(r0)
	usec = int32(r1)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

func libc_gettimeofday_trampoline()

//go:linkname libc_gettimeofday libc_gettimeofday
//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Fstat(fd int, stat *Stat_t) (err error) {
	_, _, e1 := syscall_syscall(funcPC(libc_fstat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	if e1 != 0 {

M vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_11.go => vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.1_11.go +10 -12
@@ 966,6 966,16 @@ func Getsid(pid int) (sid int, err error) {

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Gettimeofday(tp *Timeval) (err error) {
	_, _, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Getuid() (uid int) {
	r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
	uid = int(r0)


@@ 1682,18 1692,6 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) {

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func gettimeofday(tp *Timeval) (sec int32, usec int32, err error) {
	r0, r1, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	sec = int32(r0)
	usec = int32(r1)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Fstat(fd int, stat *Stat_t) (err error) {
	_, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	if e1 != 0 {

M vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go => vendor/golang.org/x/sys/unix/zsyscall_darwin_arm.go +15 -17
@@ 1376,6 1376,21 @@ func libc_getsid_trampoline()

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Gettimeofday(tp *Timeval) (err error) {
	_, _, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

func libc_gettimeofday_trampoline()

//go:linkname libc_gettimeofday libc_gettimeofday
//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Getuid() (uid int) {
	r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
	uid = int(r0)


@@ 2342,23 2357,6 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) {

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func gettimeofday(tp *Timeval) (sec int32, usec int32, err error) {
	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
	sec = int32(r0)
	usec = int32(r1)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

func libc_gettimeofday_trampoline()

//go:linkname libc_gettimeofday libc_gettimeofday
//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Fstat(fd int, stat *Stat_t) (err error) {
	_, _, e1 := syscall_syscall(funcPC(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	if e1 != 0 {

M vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_11.go => vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.1_11.go +10 -12
@@ 966,6 966,16 @@ func Getsid(pid int) (sid int, err error) {

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Gettimeofday(tp *Timeval) (err error) {
	_, _, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Getuid() (uid int) {
	r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
	uid = int(r0)


@@ 1682,18 1692,6 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) {

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func gettimeofday(tp *Timeval) (sec int64, usec int32, err error) {
	r0, r1, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	sec = int64(r0)
	usec = int32(r1)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Fstat(fd int, stat *Stat_t) (err error) {
	_, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	if e1 != 0 {

M vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go => vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go +15 -17
@@ 1376,6 1376,21 @@ func libc_getsid_trampoline()

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Gettimeofday(tp *Timeval) (err error) {
	_, _, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

func libc_gettimeofday_trampoline()

//go:linkname libc_gettimeofday libc_gettimeofday
//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Getuid() (uid int) {
	r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
	uid = int(r0)


@@ 2342,23 2357,6 @@ func writelen(fd int, buf *byte, nbuf int) (n int, err error) {

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func gettimeofday(tp *Timeval) (sec int64, usec int32, err error) {
	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
	sec = int64(r0)
	usec = int32(r1)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

func libc_gettimeofday_trampoline()

//go:linkname libc_gettimeofday libc_gettimeofday
//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func Fstat(fd int, stat *Stat_t) (err error) {
	_, _, e1 := syscall_syscall(funcPC(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	if e1 != 0 {

M vendor/golang.org/x/sys/unix/zsysctl_openbsd_386.go => vendor/golang.org/x/sys/unix/zsysctl_openbsd_386.go +2 -1
@@ 1,4 1,4 @@
// mksysctl_openbsd.pl
// go run mksysctl_openbsd.go
// Code generated by the command above; DO NOT EDIT.

// +build 386,openbsd


@@ 30,6 30,7 @@ var sysctlMib = []mibentry{
	{"hw.model", []_C_int{6, 2}},
	{"hw.ncpu", []_C_int{6, 3}},
	{"hw.ncpufound", []_C_int{6, 21}},
	{"hw.ncpuonline", []_C_int{6, 25}},
	{"hw.pagesize", []_C_int{6, 7}},
	{"hw.physmem", []_C_int{6, 19}},
	{"hw.product", []_C_int{6, 15}},

M vendor/golang.org/x/sys/unix/zsysctl_openbsd_amd64.go => vendor/golang.org/x/sys/unix/zsysctl_openbsd_amd64.go +1 -0
@@ 31,6 31,7 @@ var sysctlMib = []mibentry{
	{"hw.model", []_C_int{6, 2}},
	{"hw.ncpu", []_C_int{6, 3}},
	{"hw.ncpufound", []_C_int{6, 21}},
	{"hw.ncpuonline", []_C_int{6, 25}},
	{"hw.pagesize", []_C_int{6, 7}},
	{"hw.perfpolicy", []_C_int{6, 23}},
	{"hw.physmem", []_C_int{6, 19}},

M vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm.go => vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm.go +1 -0
@@ 30,6 30,7 @@ var sysctlMib = []mibentry{
	{"hw.model", []_C_int{6, 2}},
	{"hw.ncpu", []_C_int{6, 3}},
	{"hw.ncpufound", []_C_int{6, 21}},
	{"hw.ncpuonline", []_C_int{6, 25}},
	{"hw.pagesize", []_C_int{6, 7}},
	{"hw.physmem", []_C_int{6, 19}},
	{"hw.product", []_C_int{6, 15}},

M vendor/golang.org/x/sys/windows/dll_windows.go => vendor/golang.org/x/sys/windows/dll_windows.go +29 -0
@@ 104,6 104,35 @@ func (d *DLL) MustFindProc(name string) *Proc {
	return p
}

// FindProcByOrdinal searches DLL d for procedure by ordinal and returns *Proc
// if found. It returns an error if search fails.
func (d *DLL) FindProcByOrdinal(ordinal uintptr) (proc *Proc, err error) {
	a, e := GetProcAddressByOrdinal(d.Handle, ordinal)
	name := "#" + itoa(int(ordinal))
	if e != nil {
		return nil, &DLLError{
			Err:     e,
			ObjName: name,
			Msg:     "Failed to find " + name + " procedure in " + d.Name + ": " + e.Error(),
		}
	}
	p := &Proc{
		Dll:  d,
		Name: name,
		addr: a,
	}
	return p, nil
}

// MustFindProcByOrdinal is like FindProcByOrdinal but panics if search fails.
func (d *DLL) MustFindProcByOrdinal(ordinal uintptr) *Proc {
	p, e := d.FindProcByOrdinal(ordinal)
	if e != nil {
		panic(e)
	}
	return p
}

// Release unloads DLL d from memory.
func (d *DLL) Release() (err error) {
	return FreeLibrary(d.Handle)

M vendor/golang.org/x/sys/windows/syscall_windows.go => vendor/golang.org/x/sys/windows/syscall_windows.go +6 -1
@@ 1181,7 1181,12 @@ type IPv6Mreq struct {
	Interface uint32
}

func GetsockoptInt(fd Handle, level, opt int) (int, error) { return -1, syscall.EWINDOWS }
func GetsockoptInt(fd Handle, level, opt int) (int, error) {
	v := int32(0)
	l := int32(unsafe.Sizeof(v))
	err := Getsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&v)), &l)
	return int(v), err
}

func SetsockoptLinger(fd Handle, level, opt int, l *Linger) (err error) {
	sys := sysLinger{Onoff: uint16(l.Onoff), Linger: uint16(l.Linger)}

M vendor/gopkg.in/yaml.v2/apic.go => vendor/gopkg.in/yaml.v2/apic.go +1 -0
@@ 86,6 86,7 @@ func yaml_emitter_initialize(emitter *yaml_emitter_t) {
		raw_buffer: make([]byte, 0, output_raw_buffer_size),
		states:     make([]yaml_emitter_state_t, 0, initial_stack_size),
		events:     make([]yaml_event_t, 0, initial_queue_size),
		best_width: -1,
	}
}


M vendor/modules.txt => vendor/modules.txt +7 -7
@@ 14,7 14,7 @@ a4.io/go/indieauth
# a4.io/ssse v0.0.0-20181202155639-1949828a8689
## explicit
a4.io/ssse/pkg/client
# github.com/alecthomas/chroma v0.7.2
# github.com/alecthomas/chroma v0.7.3
## explicit
github.com/alecthomas/chroma
github.com/alecthomas/chroma/formatters/html


@@ 46,7 46,7 @@ github.com/alecthomas/chroma/lexers/w
github.com/alecthomas/chroma/lexers/x
github.com/alecthomas/chroma/lexers/y
github.com/alecthomas/chroma/styles
# github.com/aws/aws-sdk-go v1.30.23
# github.com/aws/aws-sdk-go v1.30.27
## explicit
github.com/aws/aws-sdk-go/aws
github.com/aws/aws-sdk-go/aws/arn


@@ 173,7 173,7 @@ github.com/justinas/nosurf
github.com/kevinburke/ssh_config
# github.com/klauspost/cpuid v1.2.4
github.com/klauspost/cpuid
# github.com/klauspost/reedsolomon v1.9.6
# github.com/klauspost/reedsolomon v1.9.7
## explicit
github.com/klauspost/reedsolomon
# github.com/konsorten/go-windows-terminal-sequences v1.0.3


@@ 272,7 272,7 @@ github.com/yuin/gopher-lua/pm
# github.com/zpatrick/rbac v0.0.0-20180829190353-d2c4f050cf28
## explicit
github.com/zpatrick/rbac
# golang.org/x/crypto v0.0.0-20200429183012-4b2356b1ed79
# golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37
## explicit
golang.org/x/crypto/acme
golang.org/x/crypto/acme/autocert


@@ 299,7 299,7 @@ golang.org/x/crypto/ssh
golang.org/x/crypto/ssh/agent
golang.org/x/crypto/ssh/internal/bcrypt_pbkdf
golang.org/x/crypto/ssh/knownhosts
# golang.org/x/net v0.0.0-20200506145744-7e3656a0809f
# golang.org/x/net v0.0.0-20200513185701-a91f0712d120
## explicit
golang.org/x/net/context
golang.org/x/net/html


@@ 307,7 307,7 @@ golang.org/x/net/html/atom
golang.org/x/net/idna
golang.org/x/net/internal/socks
golang.org/x/net/proxy
# golang.org/x/sys v0.0.0-20200501145240-bc7a7d42d5c3
# golang.org/x/sys v0.0.0-20200513112337-417ce2331b5c
## explicit
golang.org/x/sys/cpu
golang.org/x/sys/internal/unsafeheader


@@ 413,7 413,7 @@ gopkg.in/src-d/go-git.v4/utils/merkletrie/internal/frame
gopkg.in/src-d/go-git.v4/utils/merkletrie/noder
# gopkg.in/warnings.v0 v0.1.2
gopkg.in/warnings.v0
# gopkg.in/yaml.v2 v2.2.8
# gopkg.in/yaml.v2 v2.3.0
## explicit
gopkg.in/yaml.v2
# mvdan.cc/xurls v1.1.0