adds progressbar to the commandline

2021-09-01 13:08:04 +02:00 · 2021-09-01 13:08:04 +02:00 · 409955b69c
commit 409955b69c
parent f2dbd36266
392 changed files with 189189 additions and 12 deletions
--- a/README.md
+++ b/README.md
@ -63,16 +63,16 @@ if err := don.Ready(
 ## Functions
-### func [Cmd](/don.go#L68)
+### func [Cmd](/don.go#L69)
 `func Cmd(c string) func() bool`
 Cmd returns a `func() bool` for working with `don.Ready()`. It executes a command and
 returns a true if everything looks fine or a false if there was some kind of error.
-### func [Ready](/don.go#L86)
+### func [Ready](/don.go#L87)
-`func Ready(f func() bool, timeout time.Duration, retry time.Duration) error`
+`func Ready(f func() bool, timeout time.Duration, retry time.Duration, bar bool) error`
 Ready takes a function that executes something and returns a bool to indicate if
 something is ready or not. It returns an error if it timeouts.
--- a/cmd/cmds/root.go
+++ b/cmd/cmds/root.go
@ -11,14 +11,16 @@ import (
 )
 const (
-	defaultTimeout = 10 * time.Second
+	defaultTimeout     = 10 * time.Second
-	defaultRetry   = time.Second
+	defaultRetry       = time.Second
 	defaultProgressbar = true
 )
 var (
-	command string
+	command     string
-	timeout time.Duration
+	timeout     time.Duration
-	retry   time.Duration
+	retry       time.Duration
 	progressbar bool
 )
 var (
@ -30,7 +32,7 @@ var (
 var rootCmd = &cobra.Command{
 	Use: "don [command]",
 	Run: func(cmd *cobra.Command, args []string) {
-		if err := don.Ready(don.Cmd(command), timeout, retry); err != nil {
+		if err := don.Ready(don.Cmd(command), timeout, retry, progressbar); err != nil {
 			log.Fatal().Err(err).Msg("received error")
 		}
@ -57,6 +59,7 @@ func init() {
 	rootCmd.Flags().DurationVarP(&timeout, "timeout", "t", defaultTimeout, "timeout")
 	rootCmd.Flags().DurationVarP(&retry, "retry", "r", defaultRetry, "retry")
 	rootCmd.Flags().BoolVarP(&progressbar, "progressbar", "p", defaultProgressbar, "progressbar")
 }
 func Execute() error {
--- a/don.go
+++ b/don.go
@ -59,6 +59,7 @@ import (
 	"time"
 	"github.com/rs/zerolog/log"
 	"github.com/schollz/progressbar/v3"
 )
 var errTimeout = errors.New("timeout")
@ -83,7 +84,7 @@ func Cmd(c string) func() bool {
 // Ready takes a function that executes something and returns a bool to indicate if
 // something is ready or not. It returns an error if it timeouts.
-func Ready(f func() bool, timeout time.Duration, retry time.Duration) error {
+func Ready(f func() bool, timeout time.Duration, retry time.Duration, bar bool) error {
 	chReady := make(chan struct{})
 	go func() {
@ -94,8 +95,18 @@ func Ready(f func() bool, timeout time.Duration, retry time.Duration) error {
 				return
 			}
-			<-time.After(retry)
+			if bar {
-			log.Info().Msg("retrying")
+				d := int64(retry / time.Second)
 				bar := progressbar.Default(d)
 				for i := int64(0); i < d; i++ {
 					bar.Add(1)
 					time.Sleep(time.Second)
 				}
 			} else {
 				<-time.After(retry)
 				log.Info().Msg("retrying")
 			}
 		}
 	}()
--- a/go.mod
+++ b/go.mod
@ -4,5 +4,6 @@ go 1.16
 require (
 	github.com/rs/zerolog v1.22.0
 	github.com/schollz/progressbar/v3 v3.8.2
 	github.com/spf13/cobra v1.1.3
 )
--- a/go.sum
+++ b/go.sum
@ -32,6 +32,7 @@ github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7
 github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
 github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 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/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
@ -95,6 +96,7 @@ github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCV
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
 github.com/k0kubun/go-ansi v0.0.0-20180517002512-3bf9e2903213/go.mod h1:vNUNkEQ1e29fT/6vq2aBdFsgNPmy8qMdSay1npru+Sw=
 github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
@ -105,9 +107,14 @@ github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-isatty v0.0.13/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU=
 github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
 github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
 github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db h1:62I3jR2EmQ4l5rM/4FEfDWcRD+abF5XlKShorW5LRoQ=
 github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw=
 github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
@ -124,6 +131,7 @@ github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/9
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 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/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
@ -135,6 +143,8 @@ github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y8
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
 github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
@ -142,6 +152,8 @@ github.com/rs/zerolog v1.22.0 h1:XrVUjV4K+izZpKXZHlPrYQiDtmdGiCylnT4i43AAWxg=
 github.com/rs/zerolog v1.22.0/go.mod h1:ZPhntP/xmq1nnND05hhpAh2QMhSsA4UN3MGZ6O2J3hM=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
 github.com/schollz/progressbar/v3 v3.8.2 h1:2kZJwZCpb+E/V79kGO7daeq+hUwUJW0A5QD1Wv455dA=
 github.com/schollz/progressbar/v3 v3.8.2/go.mod h1:9KHLdyuXczIsyStQwzvW8xiELskmX7fQMaZdN23nAv8=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
@ -161,6 +173,7 @@ github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5q
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 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=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
@ -179,6 +192,8 @@ golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e h1:gsTQYXdTw2Gq7RBsWvlQ91b+aEQ6bXFUngBGuR8sPpI=
 golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@ -213,6 +228,7 @@ golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@ -235,8 +251,16 @@ golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22 h1:RqytpXGR1iVNX7psjB3ff8y7sNFinVFvkx1c8SjBkio=
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b h1:9zKuko04nR4gjZ4+DNjHqRlAJqbJETHwiNKDqTfOjfE=
 golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
--- a/vendor/github.com/mattn/go-runewidth/.travis.yml
+++ b/vendor/github.com/mattn/go-runewidth/.travis.yml
@ -0,0 +1,16 @@
 language: go
 sudo: false
 go:
  - 1.13.x
  - tip
 before_install:
  - go get -t -v ./...
 script:
  - go generate
  - git diff --cached --exit-code
  - ./go.test.sh
 after_success:
  - bash <(curl -s https://codecov.io/bash)
--- a/vendor/github.com/mattn/go-runewidth/LICENSE
+++ b/vendor/github.com/mattn/go-runewidth/LICENSE
@ -0,0 +1,21 @@
 The MIT License (MIT)
 Copyright (c) 2016 Yasuhiro Matsumoto
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
--- a/vendor/github.com/mattn/go-runewidth/README.md
+++ b/vendor/github.com/mattn/go-runewidth/README.md
@ -0,0 +1,27 @@
 go-runewidth
 ============
 [![Build Status](https://travis-ci.org/mattn/go-runewidth.png?branch=master)](https://travis-ci.org/mattn/go-runewidth)
 [![Codecov](https://codecov.io/gh/mattn/go-runewidth/branch/master/graph/badge.svg)](https://codecov.io/gh/mattn/go-runewidth)
 [![GoDoc](https://godoc.org/github.com/mattn/go-runewidth?status.svg)](http://godoc.org/github.com/mattn/go-runewidth)
 [![Go Report Card](https://goreportcard.com/badge/github.com/mattn/go-runewidth)](https://goreportcard.com/report/github.com/mattn/go-runewidth)
 Provides functions to get fixed width of the character or string.
 Usage
 -----
 ```go
 runewidth.StringWidth("つのだ☆HIRO") == 12
 ```
 Author
 ------
 Yasuhiro Matsumoto
 License
 -------
 under the MIT License: http://mattn.mit-license.org/2013
--- a/vendor/github.com/mattn/go-runewidth/go.mod
+++ b/vendor/github.com/mattn/go-runewidth/go.mod
@ -0,0 +1,5 @@
 module github.com/mattn/go-runewidth
 go 1.9
 require github.com/rivo/uniseg v0.2.0
--- a/vendor/github.com/mattn/go-runewidth/go.sum
+++ b/vendor/github.com/mattn/go-runewidth/go.sum
@ -0,0 +1,2 @@
 github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
--- a/vendor/github.com/mattn/go-runewidth/go.test.sh
+++ b/vendor/github.com/mattn/go-runewidth/go.test.sh
@ -0,0 +1,12 @@
 #!/usr/bin/env bash
 set -e
 echo "" > coverage.txt
 for d in $(go list ./... | grep -v vendor); do
    go test -race -coverprofile=profile.out -covermode=atomic "$d"
    if [ -f profile.out ]; then
        cat profile.out >> coverage.txt
        rm profile.out
    fi
 done
--- a/vendor/github.com/mattn/go-runewidth/runewidth.go
+++ b/vendor/github.com/mattn/go-runewidth/runewidth.go
@ -0,0 +1,273 @@
 package runewidth
 import (
 	"os"
 	"github.com/rivo/uniseg"
 )
 //go:generate go run script/generate.go
 var (
 	// EastAsianWidth will be set true if the current locale is CJK
 	EastAsianWidth bool
 	// StrictEmojiNeutral should be set false if handle broken fonts
 	StrictEmojiNeutral bool = true
 	// DefaultCondition is a condition in current locale
 	DefaultCondition = &Condition{
 		EastAsianWidth:     false,
 		StrictEmojiNeutral: true,
 	}
 )
 func init() {
 	handleEnv()
 }
 func handleEnv() {
 	env := os.Getenv("RUNEWIDTH_EASTASIAN")
 	if env == "" {
 		EastAsianWidth = IsEastAsian()
 	} else {
 		EastAsianWidth = env == "1"
 	}
 	// update DefaultCondition
 	DefaultCondition.EastAsianWidth = EastAsianWidth
 }
 type interval struct {
 	first rune
 	last  rune
 }
 type table []interval
 func inTables(r rune, ts ...table) bool {
 	for _, t := range ts {
 		if inTable(r, t) {
 			return true
 		}
 	}
 	return false
 }
 func inTable(r rune, t table) bool {
 	if r < t[0].first {
 		return false
 	}
 	bot := 0
 	top := len(t) - 1
 	for top >= bot {
 		mid := (bot + top) >> 1
 		switch {
 		case t[mid].last < r:
 			bot = mid + 1
 		case t[mid].first > r:
 			top = mid - 1
 		default:
 			return true
 		}
 	}
 	return false
 }
 var private = table{
 	{0x00E000, 0x00F8FF}, {0x0F0000, 0x0FFFFD}, {0x100000, 0x10FFFD},
 }
 var nonprint = table{
 	{0x0000, 0x001F}, {0x007F, 0x009F}, {0x00AD, 0x00AD},
 	{0x070F, 0x070F}, {0x180B, 0x180E}, {0x200B, 0x200F},
 	{0x2028, 0x202E}, {0x206A, 0x206F}, {0xD800, 0xDFFF},
 	{0xFEFF, 0xFEFF}, {0xFFF9, 0xFFFB}, {0xFFFE, 0xFFFF},
 }
 // Condition have flag EastAsianWidth whether the current locale is CJK or not.
 type Condition struct {
 	EastAsianWidth     bool
 	StrictEmojiNeutral bool
 }
 // NewCondition return new instance of Condition which is current locale.
 func NewCondition() *Condition {
 	return &Condition{
 		EastAsianWidth:     EastAsianWidth,
 		StrictEmojiNeutral: StrictEmojiNeutral,
 	}
 }
 // RuneWidth returns the number of cells in r.
 // See http://www.unicode.org/reports/tr11/
 func (c *Condition) RuneWidth(r rune) int {
 	// optimized version, verified by TestRuneWidthChecksums()
 	if !c.EastAsianWidth {
 		switch {
 		case r < 0x20 || r > 0x10FFFF:
 			return 0
 		case (r >= 0x7F && r <= 0x9F) || r == 0xAD: // nonprint
 			return 0
 		case r < 0x300:
 			return 1
 		case inTable(r, narrow):
 			return 1
 		case inTables(r, nonprint, combining):
 			return 0
 		case inTable(r, doublewidth):
 			return 2
 		default:
 			return 1
 		}
 	} else {
 		switch {
 		case r < 0 || r > 0x10FFFF || inTables(r, nonprint, combining):
 			return 0
 		case inTable(r, narrow):
 			return 1
 		case inTables(r, ambiguous, doublewidth):
 			return 2
 		case !c.StrictEmojiNeutral && inTables(r, ambiguous, emoji, narrow):
 			return 2
 		default:
 			return 1
 		}
 	}
 }
 // StringWidth return width as you can see
 func (c *Condition) StringWidth(s string) (width int) {
 	g := uniseg.NewGraphemes(s)
 	for g.Next() {
 		var chWidth int
 		for _, r := range g.Runes() {
 			chWidth = c.RuneWidth(r)
 			if chWidth > 0 {
 				break // Our best guess at this point is to use the width of the first non-zero-width rune.
 			}
 		}
 		width += chWidth
 	}
 	return
 }
 // Truncate return string truncated with w cells
 func (c *Condition) Truncate(s string, w int, tail string) string {
 	if c.StringWidth(s) <= w {
 		return s
 	}
 	w -= c.StringWidth(tail)
 	var width int
 	pos := len(s)
 	g := uniseg.NewGraphemes(s)
 	for g.Next() {
 		var chWidth int
 		for _, r := range g.Runes() {
 			chWidth = c.RuneWidth(r)
 			if chWidth > 0 {
 				break // See StringWidth() for details.
 			}
 		}
 		if width+chWidth > w {
 			pos, _ = g.Positions()
 			break
 		}
 		width += chWidth
 	}
 	return s[:pos] + tail
 }
 // Wrap return string wrapped with w cells
 func (c *Condition) Wrap(s string, w int) string {
 	width := 0
 	out := ""
 	for _, r := range []rune(s) {
 		cw := c.RuneWidth(r)
 		if r == '\n' {
 			out += string(r)
 			width = 0
 			continue
 		} else if width+cw > w {
 			out += "\n"
 			width = 0
 			out += string(r)
 			width += cw
 			continue
 		}
 		out += string(r)
 		width += cw
 	}
 	return out
 }
 // FillLeft return string filled in left by spaces in w cells
 func (c *Condition) FillLeft(s string, w int) string {
 	width := c.StringWidth(s)
 	count := w - width
 	if count > 0 {
 		b := make([]byte, count)
 		for i := range b {
 			b[i] = ' '
 		}
 		return string(b) + s
 	}
 	return s
 }
 // FillRight return string filled in left by spaces in w cells
 func (c *Condition) FillRight(s string, w int) string {
 	width := c.StringWidth(s)
 	count := w - width
 	if count > 0 {
 		b := make([]byte, count)
 		for i := range b {
 			b[i] = ' '
 		}
 		return s + string(b)
 	}
 	return s
 }
 // RuneWidth returns the number of cells in r.
 // See http://www.unicode.org/reports/tr11/
 func RuneWidth(r rune) int {
 	return DefaultCondition.RuneWidth(r)
 }
 // IsAmbiguousWidth returns whether is ambiguous width or not.
 func IsAmbiguousWidth(r rune) bool {
 	return inTables(r, private, ambiguous)
 }
 // IsNeutralWidth returns whether is neutral width or not.
 func IsNeutralWidth(r rune) bool {
 	return inTable(r, neutral)
 }
 // StringWidth return width as you can see
 func StringWidth(s string) (width int) {
 	return DefaultCondition.StringWidth(s)
 }
 // Truncate return string truncated with w cells
 func Truncate(s string, w int, tail string) string {
 	return DefaultCondition.Truncate(s, w, tail)
 }
 // Wrap return string wrapped with w cells
 func Wrap(s string, w int) string {
 	return DefaultCondition.Wrap(s, w)
 }
 // FillLeft return string filled in left by spaces in w cells
 func FillLeft(s string, w int) string {
 	return DefaultCondition.FillLeft(s, w)
 }
 // FillRight return string filled in left by spaces in w cells
 func FillRight(s string, w int) string {
 	return DefaultCondition.FillRight(s, w)
 }
--- a/vendor/github.com/mattn/go-runewidth/runewidth_appengine.go
+++ b/vendor/github.com/mattn/go-runewidth/runewidth_appengine.go
@ -0,0 +1,8 @@
 // +build appengine
 package runewidth
 // IsEastAsian return true if the current locale is CJK
 func IsEastAsian() bool {
 	return false
 }
--- a/vendor/github.com/mattn/go-runewidth/runewidth_js.go
+++ b/vendor/github.com/mattn/go-runewidth/runewidth_js.go
@ -0,0 +1,9 @@
 // +build js
 // +build !appengine
 package runewidth
 func IsEastAsian() bool {
 	// TODO: Implement this for the web. Detect east asian in a compatible way, and return true.
 	return false
 }
--- a/vendor/github.com/mattn/go-runewidth/runewidth_posix.go
+++ b/vendor/github.com/mattn/go-runewidth/runewidth_posix.go
@ -0,0 +1,82 @@
 // +build !windows
 // +build !js
 // +build !appengine
 package runewidth
 import (
 	"os"
 	"regexp"
 	"strings"
 )
 var reLoc = regexp.MustCompile(`^[a-z][a-z][a-z]?(?:_[A-Z][A-Z])?\.(.+)`)
 var mblenTable = map[string]int{
 	"utf-8":   6,
 	"utf8":    6,
 	"jis":     8,
 	"eucjp":   3,
 	"euckr":   2,
 	"euccn":   2,
 	"sjis":    2,
 	"cp932":   2,
 	"cp51932": 2,
 	"cp936":   2,
 	"cp949":   2,
 	"cp950":   2,
 	"big5":    2,
 	"gbk":     2,
 	"gb2312":  2,
 }
 func isEastAsian(locale string) bool {
 	charset := strings.ToLower(locale)
 	r := reLoc.FindStringSubmatch(locale)
 	if len(r) == 2 {
 		charset = strings.ToLower(r[1])
 	}
 	if strings.HasSuffix(charset, "@cjk_narrow") {
 		return false
 	}
 	for pos, b := range []byte(charset) {
 		if b == '@' {
 			charset = charset[:pos]
 			break
 		}
 	}
 	max := 1
 	if m, ok := mblenTable[charset]; ok {
 		max = m
 	}
 	if max > 1 && (charset[0] != 'u' ||
 		strings.HasPrefix(locale, "ja") ||
 		strings.HasPrefix(locale, "ko") ||
 		strings.HasPrefix(locale, "zh")) {
 		return true
 	}
 	return false
 }
 // IsEastAsian return true if the current locale is CJK
 func IsEastAsian() bool {
 	locale := os.Getenv("LC_ALL")
 	if locale == "" {
 		locale = os.Getenv("LC_CTYPE")
 	}
 	if locale == "" {
 		locale = os.Getenv("LANG")
 	}
 	// ignore C locale
 	if locale == "POSIX" || locale == "C" {
 		return false
 	}
 	if len(locale) > 1 && locale[0] == 'C' && (locale[1] == '.' || locale[1] == '-') {
 		return false
 	}
 	return isEastAsian(locale)
 }
--- a/vendor/github.com/mattn/go-runewidth/runewidth_table.go
+++ b/vendor/github.com/mattn/go-runewidth/runewidth_table.go
@ -0,0 +1,439 @@
 // Code generated by script/generate.go. DO NOT EDIT.
 package runewidth
 var combining = table{
 	{0x0300, 0x036F}, {0x0483, 0x0489}, {0x07EB, 0x07F3},
 	{0x0C00, 0x0C00}, {0x0C04, 0x0C04}, {0x0D00, 0x0D01},
 	{0x135D, 0x135F}, {0x1A7F, 0x1A7F}, {0x1AB0, 0x1AC0},
 	{0x1B6B, 0x1B73}, {0x1DC0, 0x1DF9}, {0x1DFB, 0x1DFF},
 	{0x20D0, 0x20F0}, {0x2CEF, 0x2CF1}, {0x2DE0, 0x2DFF},
 	{0x3099, 0x309A}, {0xA66F, 0xA672}, {0xA674, 0xA67D},
 	{0xA69E, 0xA69F}, {0xA6F0, 0xA6F1}, {0xA8E0, 0xA8F1},
 	{0xFE20, 0xFE2F}, {0x101FD, 0x101FD}, {0x10376, 0x1037A},
 	{0x10EAB, 0x10EAC}, {0x10F46, 0x10F50}, {0x11300, 0x11301},
 	{0x1133B, 0x1133C}, {0x11366, 0x1136C}, {0x11370, 0x11374},
 	{0x16AF0, 0x16AF4}, {0x1D165, 0x1D169}, {0x1D16D, 0x1D172},
 	{0x1D17B, 0x1D182}, {0x1D185, 0x1D18B}, {0x1D1AA, 0x1D1AD},
 	{0x1D242, 0x1D244}, {0x1E000, 0x1E006}, {0x1E008, 0x1E018},
 	{0x1E01B, 0x1E021}, {0x1E023, 0x1E024}, {0x1E026, 0x1E02A},
 	{0x1E8D0, 0x1E8D6},
 }
 var doublewidth = table{
 	{0x1100, 0x115F}, {0x231A, 0x231B}, {0x2329, 0x232A},
 	{0x23E9, 0x23EC}, {0x23F0, 0x23F0}, {0x23F3, 0x23F3},
 	{0x25FD, 0x25FE}, {0x2614, 0x2615}, {0x2648, 0x2653},
 	{0x267F, 0x267F}, {0x2693, 0x2693}, {0x26A1, 0x26A1},
 	{0x26AA, 0x26AB}, {0x26BD, 0x26BE}, {0x26C4, 0x26C5},
 	{0x26CE, 0x26CE}, {0x26D4, 0x26D4}, {0x26EA, 0x26EA},
 	{0x26F2, 0x26F3}, {0x26F5, 0x26F5}, {0x26FA, 0x26FA},
 	{0x26FD, 0x26FD}, {0x2705, 0x2705}, {0x270A, 0x270B},
 	{0x2728, 0x2728}, {0x274C, 0x274C}, {0x274E, 0x274E},
 	{0x2753, 0x2755}, {0x2757, 0x2757}, {0x2795, 0x2797},
 	{0x27B0, 0x27B0}, {0x27BF, 0x27BF}, {0x2B1B, 0x2B1C},
 	{0x2B50, 0x2B50}, {0x2B55, 0x2B55}, {0x2E80, 0x2E99},
 	{0x2E9B, 0x2EF3}, {0x2F00, 0x2FD5}, {0x2FF0, 0x2FFB},
 	{0x3000, 0x303E}, {0x3041, 0x3096}, {0x3099, 0x30FF},
 	{0x3105, 0x312F}, {0x3131, 0x318E}, {0x3190, 0x31E3},
 	{0x31F0, 0x321E}, {0x3220, 0x3247}, {0x3250, 0x4DBF},
 	{0x4E00, 0xA48C}, {0xA490, 0xA4C6}, {0xA960, 0xA97C},
 	{0xAC00, 0xD7A3}, {0xF900, 0xFAFF}, {0xFE10, 0xFE19},
 	{0xFE30, 0xFE52}, {0xFE54, 0xFE66}, {0xFE68, 0xFE6B},
 	{0xFF01, 0xFF60}, {0xFFE0, 0xFFE6}, {0x16FE0, 0x16FE4},
 	{0x16FF0, 0x16FF1}, {0x17000, 0x187F7}, {0x18800, 0x18CD5},
 	{0x18D00, 0x18D08}, {0x1B000, 0x1B11E}, {0x1B150, 0x1B152},
 	{0x1B164, 0x1B167}, {0x1B170, 0x1B2FB}, {0x1F004, 0x1F004},
 	{0x1F0CF, 0x1F0CF}, {0x1F18E, 0x1F18E}, {0x1F191, 0x1F19A},
 	{0x1F200, 0x1F202}, {0x1F210, 0x1F23B}, {0x1F240, 0x1F248},
 	{0x1F250, 0x1F251}, {0x1F260, 0x1F265}, {0x1F300, 0x1F320},
 	{0x1F32D, 0x1F335}, {0x1F337, 0x1F37C}, {0x1F37E, 0x1F393},
 	{0x1F3A0, 0x1F3CA}, {0x1F3CF, 0x1F3D3}, {0x1F3E0, 0x1F3F0},
 	{0x1F3F4, 0x1F3F4}, {0x1F3F8, 0x1F43E}, {0x1F440, 0x1F440},
 	{0x1F442, 0x1F4FC}, {0x1F4FF, 0x1F53D}, {0x1F54B, 0x1F54E},
 	{0x1F550, 0x1F567}, {0x1F57A, 0x1F57A}, {0x1F595, 0x1F596},
 	{0x1F5A4, 0x1F5A4}, {0x1F5FB, 0x1F64F}, {0x1F680, 0x1F6C5},
 	{0x1F6CC, 0x1F6CC}, {0x1F6D0, 0x1F6D2}, {0x1F6D5, 0x1F6D7},
 	{0x1F6EB, 0x1F6EC}, {0x1F6F4, 0x1F6FC}, {0x1F7E0, 0x1F7EB},
 	{0x1F90C, 0x1F93A}, {0x1F93C, 0x1F945}, {0x1F947, 0x1F978},
 	{0x1F97A, 0x1F9CB}, {0x1F9CD, 0x1F9FF}, {0x1FA70, 0x1FA74},
 	{0x1FA78, 0x1FA7A}, {0x1FA80, 0x1FA86}, {0x1FA90, 0x1FAA8},
 	{0x1FAB0, 0x1FAB6}, {0x1FAC0, 0x1FAC2}, {0x1FAD0, 0x1FAD6},
 	{0x20000, 0x2FFFD}, {0x30000, 0x3FFFD},
 }
 var ambiguous = table{
 	{0x00A1, 0x00A1}, {0x00A4, 0x00A4}, {0x00A7, 0x00A8},
 	{0x00AA, 0x00AA}, {0x00AD, 0x00AE}, {0x00B0, 0x00B4},
 	{0x00B6, 0x00BA}, {0x00BC, 0x00BF}, {0x00C6, 0x00C6},
 	{0x00D0, 0x00D0}, {0x00D7, 0x00D8}, {0x00DE, 0x00E1},
 	{0x00E6, 0x00E6}, {0x00E8, 0x00EA}, {0x00EC, 0x00ED},
 	{0x00F0, 0x00F0}, {0x00F2, 0x00F3}, {0x00F7, 0x00FA},
 	{0x00FC, 0x00FC}, {0x00FE, 0x00FE}, {0x0101, 0x0101},
 	{0x0111, 0x0111}, {0x0113, 0x0113}, {0x011B, 0x011B},
 	{0x0126, 0x0127}, {0x012B, 0x012B}, {0x0131, 0x0133},
 	{0x0138, 0x0138}, {0x013F, 0x0142}, {0x0144, 0x0144},
 	{0x0148, 0x014B}, {0x014D, 0x014D}, {0x0152, 0x0153},
 	{0x0166, 0x0167}, {0x016B, 0x016B}, {0x01CE, 0x01CE},
 	{0x01D0, 0x01D0}, {0x01D2, 0x01D2}, {0x01D4, 0x01D4},
 	{0x01D6, 0x01D6}, {0x01D8, 0x01D8}, {0x01DA, 0x01DA},
 	{0x01DC, 0x01DC}, {0x0251, 0x0251}, {0x0261, 0x0261},
 	{0x02C4, 0x02C4}, {0x02C7, 0x02C7}, {0x02C9, 0x02CB},
 	{0x02CD, 0x02CD}, {0x02D0, 0x02D0}, {0x02D8, 0x02DB},
 	{0x02DD, 0x02DD}, {0x02DF, 0x02DF}, {0x0300, 0x036F},
 	{0x0391, 0x03A1}, {0x03A3, 0x03A9}, {0x03B1, 0x03C1},
 	{0x03C3, 0x03C9}, {0x0401, 0x0401}, {0x0410, 0x044F},
 	{0x0451, 0x0451}, {0x2010, 0x2010}, {0x2013, 0x2016},
 	{0x2018, 0x2019}, {0x201C, 0x201D}, {0x2020, 0x2022},
 	{0x2024, 0x2027}, {0x2030, 0x2030}, {0x2032, 0x2033},
 	{0x2035, 0x2035}, {0x203B, 0x203B}, {0x203E, 0x203E},
 	{0x2074, 0x2074}, {0x207F, 0x207F}, {0x2081, 0x2084},
 	{0x20AC, 0x20AC}, {0x2103, 0x2103}, {0x2105, 0x2105},
 	{0x2109, 0x2109}, {0x2113, 0x2113}, {0x2116, 0x2116},
 	{0x2121, 0x2122}, {0x2126, 0x2126}, {0x212B, 0x212B},
 	{0x2153, 0x2154}, {0x215B, 0x215E}, {0x2160, 0x216B},
 	{0x2170, 0x2179}, {0x2189, 0x2189}, {0x2190, 0x2199},
 	{0x21B8, 0x21B9}, {0x21D2, 0x21D2}, {0x21D4, 0x21D4},
 	{0x21E7, 0x21E7}, {0x2200, 0x2200}, {0x2202, 0x2203},
 	{0x2207, 0x2208}, {0x220B, 0x220B}, {0x220F, 0x220F},
 	{0x2211, 0x2211}, {0x2215, 0x2215}, {0x221A, 0x221A},
 	{0x221D, 0x2220}, {0x2223, 0x2223}, {0x2225, 0x2225},
 	{0x2227, 0x222C}, {0x222E, 0x222E}, {0x2234, 0x2237},
 	{0x223C, 0x223D}, {0x2248, 0x2248}, {0x224C, 0x224C},
 	{0x2252, 0x2252}, {0x2260, 0x2261}, {0x2264, 0x2267},
 	{0x226A, 0x226B}, {0x226E, 0x226F}, {0x2282, 0x2283},
 	{0x2286, 0x2287}, {0x2295, 0x2295}, {0x2299, 0x2299},
 	{0x22A5, 0x22A5}, {0x22BF, 0x22BF}, {0x2312, 0x2312},
 	{0x2460, 0x24E9}, {0x24EB, 0x254B}, {0x2550, 0x2573},
 	{0x2580, 0x258F}, {0x2592, 0x2595}, {0x25A0, 0x25A1},
 	{0x25A3, 0x25A9}, {0x25B2, 0x25B3}, {0x25B6, 0x25B7},
 	{0x25BC, 0x25BD}, {0x25C0, 0x25C1}, {0x25C6, 0x25C8},
 	{0x25CB, 0x25CB}, {0x25CE, 0x25D1}, {0x25E2, 0x25E5},
 	{0x25EF, 0x25EF}, {0x2605, 0x2606}, {0x2609, 0x2609},
 	{0x260E, 0x260F}, {0x261C, 0x261C}, {0x261E, 0x261E},
 	{0x2640, 0x2640}, {0x2642, 0x2642}, {0x2660, 0x2661},
 	{0x2663, 0x2665}, {0x2667, 0x266A}, {0x266C, 0x266D},
 	{0x266F, 0x266F}, {0x269E, 0x269F}, {0x26BF, 0x26BF},
 	{0x26C6, 0x26CD}, {0x26CF, 0x26D3}, {0x26D5, 0x26E1},
 	{0x26E3, 0x26E3}, {0x26E8, 0x26E9}, {0x26EB, 0x26F1},
 	{0x26F4, 0x26F4}, {0x26F6, 0x26F9}, {0x26FB, 0x26FC},
 	{0x26FE, 0x26FF}, {0x273D, 0x273D}, {0x2776, 0x277F},
 	{0x2B56, 0x2B59}, {0x3248, 0x324F}, {0xE000, 0xF8FF},
 	{0xFE00, 0xFE0F}, {0xFFFD, 0xFFFD}, {0x1F100, 0x1F10A},
 	{0x1F110, 0x1F12D}, {0x1F130, 0x1F169}, {0x1F170, 0x1F18D},
 	{0x1F18F, 0x1F190}, {0x1F19B, 0x1F1AC}, {0xE0100, 0xE01EF},
 	{0xF0000, 0xFFFFD}, {0x100000, 0x10FFFD},
 }
 var narrow = table{
 	{0x0020, 0x007E}, {0x00A2, 0x00A3}, {0x00A5, 0x00A6},
 	{0x00AC, 0x00AC}, {0x00AF, 0x00AF}, {0x27E6, 0x27ED},
 	{0x2985, 0x2986},
 }
 var neutral = table{
 	{0x0000, 0x001F}, {0x007F, 0x00A0}, {0x00A9, 0x00A9},
 	{0x00AB, 0x00AB}, {0x00B5, 0x00B5}, {0x00BB, 0x00BB},
 	{0x00C0, 0x00C5}, {0x00C7, 0x00CF}, {0x00D1, 0x00D6},
 	{0x00D9, 0x00DD}, {0x00E2, 0x00E5}, {0x00E7, 0x00E7},
 	{0x00EB, 0x00EB}, {0x00EE, 0x00EF}, {0x00F1, 0x00F1},
 	{0x00F4, 0x00F6}, {0x00FB, 0x00FB}, {0x00FD, 0x00FD},
 	{0x00FF, 0x0100}, {0x0102, 0x0110}, {0x0112, 0x0112},
 	{0x0114, 0x011A}, {0x011C, 0x0125}, {0x0128, 0x012A},
 	{0x012C, 0x0130}, {0x0134, 0x0137}, {0x0139, 0x013E},
 	{0x0143, 0x0143}, {0x0145, 0x0147}, {0x014C, 0x014C},
 	{0x014E, 0x0151}, {0x0154, 0x0165}, {0x0168, 0x016A},
 	{0x016C, 0x01CD}, {0x01CF, 0x01CF}, {0x01D1, 0x01D1},
 	{0x01D3, 0x01D3}, {0x01D5, 0x01D5}, {0x01D7, 0x01D7},
 	{0x01D9, 0x01D9}, {0x01DB, 0x01DB}, {0x01DD, 0x0250},
 	{0x0252, 0x0260}, {0x0262, 0x02C3}, {0x02C5, 0x02C6},
 	{0x02C8, 0x02C8}, {0x02CC, 0x02CC}, {0x02CE, 0x02CF},
 	{0x02D1, 0x02D7}, {0x02DC, 0x02DC}, {0x02DE, 0x02DE},
 	{0x02E0, 0x02FF}, {0x0370, 0x0377}, {0x037A, 0x037F},
 	{0x0384, 0x038A}, {0x038C, 0x038C}, {0x038E, 0x0390},
 	{0x03AA, 0x03B0}, {0x03C2, 0x03C2}, {0x03CA, 0x0400},
 	{0x0402, 0x040F}, {0x0450, 0x0450}, {0x0452, 0x052F},
 	{0x0531, 0x0556}, {0x0559, 0x058A}, {0x058D, 0x058F},
 	{0x0591, 0x05C7}, {0x05D0, 0x05EA}, {0x05EF, 0x05F4},
 	{0x0600, 0x061C}, {0x061E, 0x070D}, {0x070F, 0x074A},
 	{0x074D, 0x07B1}, {0x07C0, 0x07FA}, {0x07FD, 0x082D},
 	{0x0830, 0x083E}, {0x0840, 0x085B}, {0x085E, 0x085E},
 	{0x0860, 0x086A}, {0x08A0, 0x08B4}, {0x08B6, 0x08C7},
 	{0x08D3, 0x0983}, {0x0985, 0x098C}, {0x098F, 0x0990},
 	{0x0993, 0x09A8}, {0x09AA, 0x09B0}, {0x09B2, 0x09B2},
 	{0x09B6, 0x09B9}, {0x09BC, 0x09C4}, {0x09C7, 0x09C8},
 	{0x09CB, 0x09CE}, {0x09D7, 0x09D7}, {0x09DC, 0x09DD},
 	{0x09DF, 0x09E3}, {0x09E6, 0x09FE}, {0x0A01, 0x0A03},
 	{0x0A05, 0x0A0A}, {0x0A0F, 0x0A10}, {0x0A13, 0x0A28},
 	{0x0A2A, 0x0A30}, {0x0A32, 0x0A33}, {0x0A35, 0x0A36},
 	{0x0A38, 0x0A39}, {0x0A3C, 0x0A3C}, {0x0A3E, 0x0A42},
 	{0x0A47, 0x0A48}, {0x0A4B, 0x0A4D}, {0x0A51, 0x0A51},
 	{0x0A59, 0x0A5C}, {0x0A5E, 0x0A5E}, {0x0A66, 0x0A76},
 	{0x0A81, 0x0A83}, {0x0A85, 0x0A8D}, {0x0A8F, 0x0A91},
 	{0x0A93, 0x0AA8}, {0x0AAA, 0x0AB0}, {0x0AB2, 0x0AB3},
 	{0x0AB5, 0x0AB9}, {0x0ABC, 0x0AC5}, {0x0AC7, 0x0AC9},
 	{0x0ACB, 0x0ACD}, {0x0AD0, 0x0AD0}, {0x0AE0, 0x0AE3},
 	{0x0AE6, 0x0AF1}, {0x0AF9, 0x0AFF}, {0x0B01, 0x0B03},
 	{0x0B05, 0x0B0C}, {0x0B0F, 0x0B10}, {0x0B13, 0x0B28},
 	{0x0B2A, 0x0B30}, {0x0B32, 0x0B33}, {0x0B35, 0x0B39},
 	{0x0B3C, 0x0B44}, {0x0B47, 0x0B48}, {0x0B4B, 0x0B4D},
 	{0x0B55, 0x0B57}, {0x0B5C, 0x0B5D}, {0x0B5F, 0x0B63},
 	{0x0B66, 0x0B77}, {0x0B82, 0x0B83}, {0x0B85, 0x0B8A},
 	{0x0B8E, 0x0B90}, {0x0B92, 0x0B95}, {0x0B99, 0x0B9A},
 	{0x0B9C, 0x0B9C}, {0x0B9E, 0x0B9F}, {0x0BA3, 0x0BA4},
 	{0x0BA8, 0x0BAA}, {0x0BAE, 0x0BB9}, {0x0BBE, 0x0BC2},
 	{0x0BC6, 0x0BC8}, {0x0BCA, 0x0BCD}, {0x0BD0, 0x0BD0},
 	{0x0BD7, 0x0BD7}, {0x0BE6, 0x0BFA}, {0x0C00, 0x0C0C},
 	{0x0C0E, 0x0C10}, {0x0C12, 0x0C28}, {0x0C2A, 0x0C39},
 	{0x0C3D, 0x0C44}, {0x0C46, 0x0C48}, {0x0C4A, 0x0C4D},
 	{0x0C55, 0x0C56}, {0x0C58, 0x0C5A}, {0x0C60, 0x0C63},
 	{0x0C66, 0x0C6F}, {0x0C77, 0x0C8C}, {0x0C8E, 0x0C90},
 	{0x0C92, 0x0CA8}, {0x0CAA, 0x0CB3}, {0x0CB5, 0x0CB9},
 	{0x0CBC, 0x0CC4}, {0x0CC6, 0x0CC8}, {0x0CCA, 0x0CCD},
 	{0x0CD5, 0x0CD6}, {0x0CDE, 0x0CDE}, {0x0CE0, 0x0CE3},
 	{0x0CE6, 0x0CEF}, {0x0CF1, 0x0CF2}, {0x0D00, 0x0D0C},
 	{0x0D0E, 0x0D10}, {0x0D12, 0x0D44}, {0x0D46, 0x0D48},
 	{0x0D4A, 0x0D4F}, {0x0D54, 0x0D63}, {0x0D66, 0x0D7F},
 	{0x0D81, 0x0D83}, {0x0D85, 0x0D96}, {0x0D9A, 0x0DB1},
 	{0x0DB3, 0x0DBB}, {0x0DBD, 0x0DBD}, {0x0DC0, 0x0DC6},
 	{0x0DCA, 0x0DCA}, {0x0DCF, 0x0DD4}, {0x0DD6, 0x0DD6},
 	{0x0DD8, 0x0DDF}, {0x0DE6, 0x0DEF}, {0x0DF2, 0x0DF4},
 	{0x0E01, 0x0E3A}, {0x0E3F, 0x0E5B}, {0x0E81, 0x0E82},
 	{0x0E84, 0x0E84}, {0x0E86, 0x0E8A}, {0x0E8C, 0x0EA3},
 	{0x0EA5, 0x0EA5}, {0x0EA7, 0x0EBD}, {0x0EC0, 0x0EC4},
 	{0x0EC6, 0x0EC6}, {0x0EC8, 0x0ECD}, {0x0ED0, 0x0ED9},
 	{0x0EDC, 0x0EDF}, {0x0F00, 0x0F47}, {0x0F49, 0x0F6C},
 	{0x0F71, 0x0F97}, {0x0F99, 0x0FBC}, {0x0FBE, 0x0FCC},
 	{0x0FCE, 0x0FDA}, {0x1000, 0x10C5}, {0x10C7, 0x10C7},
 	{0x10CD, 0x10CD}, {0x10D0, 0x10FF}, {0x1160, 0x1248},
 	{0x124A, 0x124D}, {0x1250, 0x1256}, {0x1258, 0x1258},
 	{0x125A, 0x125D}, {0x1260, 0x1288}, {0x128A, 0x128D},
 	{0x1290, 0x12B0}, {0x12B2, 0x12B5}, {0x12B8, 0x12BE},
 	{0x12C0, 0x12C0}, {0x12C2, 0x12C5}, {0x12C8, 0x12D6},
 	{0x12D8, 0x1310}, {0x1312, 0x1315}, {0x1318, 0x135A},
 	{0x135D, 0x137C}, {0x1380, 0x1399}, {0x13A0, 0x13F5},
 	{0x13F8, 0x13FD}, {0x1400, 0x169C}, {0x16A0, 0x16F8},
 	{0x1700, 0x170C}, {0x170E, 0x1714}, {0x1720, 0x1736},
 	{0x1740, 0x1753}, {0x1760, 0x176C}, {0x176E, 0x1770},
 	{0x1772, 0x1773}, {0x1780, 0x17DD}, {0x17E0, 0x17E9},
 	{0x17F0, 0x17F9}, {0x1800, 0x180E}, {0x1810, 0x1819},
 	{0x1820, 0x1878}, {0x1880, 0x18AA}, {0x18B0, 0x18F5},
 	{0x1900, 0x191E}, {0x1920, 0x192B}, {0x1930, 0x193B},
 	{0x1940, 0x1940}, {0x1944, 0x196D}, {0x1970, 0x1974},
 	{0x1980, 0x19AB}, {0x19B0, 0x19C9}, {0x19D0, 0x19DA},
 	{0x19DE, 0x1A1B}, {0x1A1E, 0x1A5E}, {0x1A60, 0x1A7C},
 	{0x1A7F, 0x1A89}, {0x1A90, 0x1A99}, {0x1AA0, 0x1AAD},
 	{0x1AB0, 0x1AC0}, {0x1B00, 0x1B4B}, {0x1B50, 0x1B7C},
 	{0x1B80, 0x1BF3}, {0x1BFC, 0x1C37}, {0x1C3B, 0x1C49},
 	{0x1C4D, 0x1C88}, {0x1C90, 0x1CBA}, {0x1CBD, 0x1CC7},
 	{0x1CD0, 0x1CFA}, {0x1D00, 0x1DF9}, {0x1DFB, 0x1F15},
 	{0x1F18, 0x1F1D}, {0x1F20, 0x1F45}, {0x1F48, 0x1F4D},
 	{0x1F50, 0x1F57}, {0x1F59, 0x1F59}, {0x1F5B, 0x1F5B},
 	{0x1F5D, 0x1F5D}, {0x1F5F, 0x1F7D}, {0x1F80, 0x1FB4},
 	{0x1FB6, 0x1FC4}, {0x1FC6, 0x1FD3}, {0x1FD6, 0x1FDB},
 	{0x1FDD, 0x1FEF}, {0x1FF2, 0x1FF4}, {0x1FF6, 0x1FFE},
 	{0x2000, 0x200F}, {0x2011, 0x2012}, {0x2017, 0x2017},
 	{0x201A, 0x201B}, {0x201E, 0x201F}, {0x2023, 0x2023},
 	{0x2028, 0x202F}, {0x2031, 0x2031}, {0x2034, 0x2034},
 	{0x2036, 0x203A}, {0x203C, 0x203D}, {0x203F, 0x2064},
 	{0x2066, 0x2071}, {0x2075, 0x207E}, {0x2080, 0x2080},
 	{0x2085, 0x208E}, {0x2090, 0x209C}, {0x20A0, 0x20A8},
 	{0x20AA, 0x20AB}, {0x20AD, 0x20BF}, {0x20D0, 0x20F0},
 	{0x2100, 0x2102}, {0x2104, 0x2104}, {0x2106, 0x2108},
 	{0x210A, 0x2112}, {0x2114, 0x2115}, {0x2117, 0x2120},
 	{0x2123, 0x2125}, {0x2127, 0x212A}, {0x212C, 0x2152},
 	{0x2155, 0x215A}, {0x215F, 0x215F}, {0x216C, 0x216F},
 	{0x217A, 0x2188}, {0x218A, 0x218B}, {0x219A, 0x21B7},
 	{0x21BA, 0x21D1}, {0x21D3, 0x21D3}, {0x21D5, 0x21E6},
 	{0x21E8, 0x21FF}, {0x2201, 0x2201}, {0x2204, 0x2206},
 	{0x2209, 0x220A}, {0x220C, 0x220E}, {0x2210, 0x2210},
 	{0x2212, 0x2214}, {0x2216, 0x2219}, {0x221B, 0x221C},
 	{0x2221, 0x2222}, {0x2224, 0x2224}, {0x2226, 0x2226},
 	{0x222D, 0x222D}, {0x222F, 0x2233}, {0x2238, 0x223B},
 	{0x223E, 0x2247}, {0x2249, 0x224B}, {0x224D, 0x2251},
 	{0x2253, 0x225F}, {0x2262, 0x2263}, {0x2268, 0x2269},
 	{0x226C, 0x226D}, {0x2270, 0x2281}, {0x2284, 0x2285},
 	{0x2288, 0x2294}, {0x2296, 0x2298}, {0x229A, 0x22A4},
 	{0x22A6, 0x22BE}, {0x22C0, 0x2311}, {0x2313, 0x2319},
 	{0x231C, 0x2328}, {0x232B, 0x23E8}, {0x23ED, 0x23EF},
 	{0x23F1, 0x23F2}, {0x23F4, 0x2426}, {0x2440, 0x244A},
 	{0x24EA, 0x24EA}, {0x254C, 0x254F}, {0x2574, 0x257F},
 	{0x2590, 0x2591}, {0x2596, 0x259F}, {0x25A2, 0x25A2},
 	{0x25AA, 0x25B1}, {0x25B4, 0x25B5}, {0x25B8, 0x25BB},
 	{0x25BE, 0x25BF}, {0x25C2, 0x25C5}, {0x25C9, 0x25CA},
 	{0x25CC, 0x25CD}, {0x25D2, 0x25E1}, {0x25E6, 0x25EE},
 	{0x25F0, 0x25FC}, {0x25FF, 0x2604}, {0x2607, 0x2608},
 	{0x260A, 0x260D}, {0x2610, 0x2613}, {0x2616, 0x261B},
 	{0x261D, 0x261D}, {0x261F, 0x263F}, {0x2641, 0x2641},
 	{0x2643, 0x2647}, {0x2654, 0x265F}, {0x2662, 0x2662},
 	{0x2666, 0x2666}, {0x266B, 0x266B}, {0x266E, 0x266E},
 	{0x2670, 0x267E}, {0x2680, 0x2692}, {0x2694, 0x269D},
 	{0x26A0, 0x26A0}, {0x26A2, 0x26A9}, {0x26AC, 0x26BC},
 	{0x26C0, 0x26C3}, {0x26E2, 0x26E2}, {0x26E4, 0x26E7},
 	{0x2700, 0x2704}, {0x2706, 0x2709}, {0x270C, 0x2727},
 	{0x2729, 0x273C}, {0x273E, 0x274B}, {0x274D, 0x274D},
 	{0x274F, 0x2752}, {0x2756, 0x2756}, {0x2758, 0x2775},
 	{0x2780, 0x2794}, {0x2798, 0x27AF}, {0x27B1, 0x27BE},
 	{0x27C0, 0x27E5}, {0x27EE, 0x2984}, {0x2987, 0x2B1A},
 	{0x2B1D, 0x2B4F}, {0x2B51, 0x2B54}, {0x2B5A, 0x2B73},
 	{0x2B76, 0x2B95}, {0x2B97, 0x2C2E}, {0x2C30, 0x2C5E},
 	{0x2C60, 0x2CF3}, {0x2CF9, 0x2D25}, {0x2D27, 0x2D27},
 	{0x2D2D, 0x2D2D}, {0x2D30, 0x2D67}, {0x2D6F, 0x2D70},
 	{0x2D7F, 0x2D96}, {0x2DA0, 0x2DA6}, {0x2DA8, 0x2DAE},
 	{0x2DB0, 0x2DB6}, {0x2DB8, 0x2DBE}, {0x2DC0, 0x2DC6},
 	{0x2DC8, 0x2DCE}, {0x2DD0, 0x2DD6}, {0x2DD8, 0x2DDE},
 	{0x2DE0, 0x2E52}, {0x303F, 0x303F}, {0x4DC0, 0x4DFF},
 	{0xA4D0, 0xA62B}, {0xA640, 0xA6F7}, {0xA700, 0xA7BF},
 	{0xA7C2, 0xA7CA}, {0xA7F5, 0xA82C}, {0xA830, 0xA839},
 	{0xA840, 0xA877}, {0xA880, 0xA8C5}, {0xA8CE, 0xA8D9},
 	{0xA8E0, 0xA953}, {0xA95F, 0xA95F}, {0xA980, 0xA9CD},
 	{0xA9CF, 0xA9D9}, {0xA9DE, 0xA9FE}, {0xAA00, 0xAA36},
 	{0xAA40, 0xAA4D}, {0xAA50, 0xAA59}, {0xAA5C, 0xAAC2},
 	{0xAADB, 0xAAF6}, {0xAB01, 0xAB06}, {0xAB09, 0xAB0E},
 	{0xAB11, 0xAB16}, {0xAB20, 0xAB26}, {0xAB28, 0xAB2E},
 	{0xAB30, 0xAB6B}, {0xAB70, 0xABED}, {0xABF0, 0xABF9},
 	{0xD7B0, 0xD7C6}, {0xD7CB, 0xD7FB}, {0xD800, 0xDFFF},
 	{0xFB00, 0xFB06}, {0xFB13, 0xFB17}, {0xFB1D, 0xFB36},
 	{0xFB38, 0xFB3C}, {0xFB3E, 0xFB3E}, {0xFB40, 0xFB41},
 	{0xFB43, 0xFB44}, {0xFB46, 0xFBC1}, {0xFBD3, 0xFD3F},
 	{0xFD50, 0xFD8F}, {0xFD92, 0xFDC7}, {0xFDF0, 0xFDFD},
 	{0xFE20, 0xFE2F}, {0xFE70, 0xFE74}, {0xFE76, 0xFEFC},
 	{0xFEFF, 0xFEFF}, {0xFFF9, 0xFFFC}, {0x10000, 0x1000B},
 	{0x1000D, 0x10026}, {0x10028, 0x1003A}, {0x1003C, 0x1003D},
 	{0x1003F, 0x1004D}, {0x10050, 0x1005D}, {0x10080, 0x100FA},
 	{0x10100, 0x10102}, {0x10107, 0x10133}, {0x10137, 0x1018E},
 	{0x10190, 0x1019C}, {0x101A0, 0x101A0}, {0x101D0, 0x101FD},
 	{0x10280, 0x1029C}, {0x102A0, 0x102D0}, {0x102E0, 0x102FB},
 	{0x10300, 0x10323}, {0x1032D, 0x1034A}, {0x10350, 0x1037A},
 	{0x10380, 0x1039D}, {0x1039F, 0x103C3}, {0x103C8, 0x103D5},
 	{0x10400, 0x1049D}, {0x104A0, 0x104A9}, {0x104B0, 0x104D3},
 	{0x104D8, 0x104FB}, {0x10500, 0x10527}, {0x10530, 0x10563},
 	{0x1056F, 0x1056F}, {0x10600, 0x10736}, {0x10740, 0x10755},
 	{0x10760, 0x10767}, {0x10800, 0x10805}, {0x10808, 0x10808},
 	{0x1080A, 0x10835}, {0x10837, 0x10838}, {0x1083C, 0x1083C},
 	{0x1083F, 0x10855}, {0x10857, 0x1089E}, {0x108A7, 0x108AF},
 	{0x108E0, 0x108F2}, {0x108F4, 0x108F5}, {0x108FB, 0x1091B},
 	{0x1091F, 0x10939}, {0x1093F, 0x1093F}, {0x10980, 0x109B7},
 	{0x109BC, 0x109CF}, {0x109D2, 0x10A03}, {0x10A05, 0x10A06},
 	{0x10A0C, 0x10A13}, {0x10A15, 0x10A17}, {0x10A19, 0x10A35},
 	{0x10A38, 0x10A3A}, {0x10A3F, 0x10A48}, {0x10A50, 0x10A58},
 	{0x10A60, 0x10A9F}, {0x10AC0, 0x10AE6}, {0x10AEB, 0x10AF6},
 	{0x10B00, 0x10B35}, {0x10B39, 0x10B55}, {0x10B58, 0x10B72},
 	{0x10B78, 0x10B91}, {0x10B99, 0x10B9C}, {0x10BA9, 0x10BAF},
 	{0x10C00, 0x10C48}, {0x10C80, 0x10CB2}, {0x10CC0, 0x10CF2},
 	{0x10CFA, 0x10D27}, {0x10D30, 0x10D39}, {0x10E60, 0x10E7E},
 	{0x10E80, 0x10EA9}, {0x10EAB, 0x10EAD}, {0x10EB0, 0x10EB1},
 	{0x10F00, 0x10F27}, {0x10F30, 0x10F59}, {0x10FB0, 0x10FCB},
 	{0x10FE0, 0x10FF6}, {0x11000, 0x1104D}, {0x11052, 0x1106F},
 	{0x1107F, 0x110C1}, {0x110CD, 0x110CD}, {0x110D0, 0x110E8},
 	{0x110F0, 0x110F9}, {0x11100, 0x11134}, {0x11136, 0x11147},
 	{0x11150, 0x11176}, {0x11180, 0x111DF}, {0x111E1, 0x111F4},
 	{0x11200, 0x11211}, {0x11213, 0x1123E}, {0x11280, 0x11286},
 	{0x11288, 0x11288}, {0x1128A, 0x1128D}, {0x1128F, 0x1129D},
 	{0x1129F, 0x112A9}, {0x112B0, 0x112EA}, {0x112F0, 0x112F9},
 	{0x11300, 0x11303}, {0x11305, 0x1130C}, {0x1130F, 0x11310},
 	{0x11313, 0x11328}, {0x1132A, 0x11330}, {0x11332, 0x11333},
 	{0x11335, 0x11339}, {0x1133B, 0x11344}, {0x11347, 0x11348},
 	{0x1134B, 0x1134D}, {0x11350, 0x11350}, {0x11357, 0x11357},
 	{0x1135D, 0x11363}, {0x11366, 0x1136C}, {0x11370, 0x11374},
 	{0x11400, 0x1145B}, {0x1145D, 0x11461}, {0x11480, 0x114C7},
 	{0x114D0, 0x114D9}, {0x11580, 0x115B5}, {0x115B8, 0x115DD},
 	{0x11600, 0x11644}, {0x11650, 0x11659}, {0x11660, 0x1166C},
 	{0x11680, 0x116B8}, {0x116C0, 0x116C9}, {0x11700, 0x1171A},
 	{0x1171D, 0x1172B}, {0x11730, 0x1173F}, {0x11800, 0x1183B},
 	{0x118A0, 0x118F2}, {0x118FF, 0x11906}, {0x11909, 0x11909},
 	{0x1190C, 0x11913}, {0x11915, 0x11916}, {0x11918, 0x11935},
 	{0x11937, 0x11938}, {0x1193B, 0x11946}, {0x11950, 0x11959},
 	{0x119A0, 0x119A7}, {0x119AA, 0x119D7}, {0x119DA, 0x119E4},
 	{0x11A00, 0x11A47}, {0x11A50, 0x11AA2}, {0x11AC0, 0x11AF8},
 	{0x11C00, 0x11C08}, {0x11C0A, 0x11C36}, {0x11C38, 0x11C45},
 	{0x11C50, 0x11C6C}, {0x11C70, 0x11C8F}, {0x11C92, 0x11CA7},
 	{0x11CA9, 0x11CB6}, {0x11D00, 0x11D06}, {0x11D08, 0x11D09},
 	{0x11D0B, 0x11D36}, {0x11D3A, 0x11D3A}, {0x11D3C, 0x11D3D},
 	{0x11D3F, 0x11D47}, {0x11D50, 0x11D59}, {0x11D60, 0x11D65},
 	{0x11D67, 0x11D68}, {0x11D6A, 0x11D8E}, {0x11D90, 0x11D91},
 	{0x11D93, 0x11D98}, {0x11DA0, 0x11DA9}, {0x11EE0, 0x11EF8},
 	{0x11FB0, 0x11FB0}, {0x11FC0, 0x11FF1}, {0x11FFF, 0x12399},
 	{0x12400, 0x1246E}, {0x12470, 0x12474}, {0x12480, 0x12543},
 	{0x13000, 0x1342E}, {0x13430, 0x13438}, {0x14400, 0x14646},
 	{0x16800, 0x16A38}, {0x16A40, 0x16A5E}, {0x16A60, 0x16A69},
 	{0x16A6E, 0x16A6F}, {0x16AD0, 0x16AED}, {0x16AF0, 0x16AF5},
 	{0x16B00, 0x16B45}, {0x16B50, 0x16B59}, {0x16B5B, 0x16B61},
 	{0x16B63, 0x16B77}, {0x16B7D, 0x16B8F}, {0x16E40, 0x16E9A},
 	{0x16F00, 0x16F4A}, {0x16F4F, 0x16F87}, {0x16F8F, 0x16F9F},
 	{0x1BC00, 0x1BC6A}, {0x1BC70, 0x1BC7C}, {0x1BC80, 0x1BC88},
 	{0x1BC90, 0x1BC99}, {0x1BC9C, 0x1BCA3}, {0x1D000, 0x1D0F5},
 	{0x1D100, 0x1D126}, {0x1D129, 0x1D1E8}, {0x1D200, 0x1D245},
 	{0x1D2E0, 0x1D2F3}, {0x1D300, 0x1D356}, {0x1D360, 0x1D378},
 	{0x1D400, 0x1D454}, {0x1D456, 0x1D49C}, {0x1D49E, 0x1D49F},
 	{0x1D4A2, 0x1D4A2}, {0x1D4A5, 0x1D4A6}, {0x1D4A9, 0x1D4AC},
 	{0x1D4AE, 0x1D4B9}, {0x1D4BB, 0x1D4BB}, {0x1D4BD, 0x1D4C3},
 	{0x1D4C5, 0x1D505}, {0x1D507, 0x1D50A}, {0x1D50D, 0x1D514},
 	{0x1D516, 0x1D51C}, {0x1D51E, 0x1D539}, {0x1D53B, 0x1D53E},
 	{0x1D540, 0x1D544}, {0x1D546, 0x1D546}, {0x1D54A, 0x1D550},
 	{0x1D552, 0x1D6A5}, {0x1D6A8, 0x1D7CB}, {0x1D7CE, 0x1DA8B},
 	{0x1DA9B, 0x1DA9F}, {0x1DAA1, 0x1DAAF}, {0x1E000, 0x1E006},
 	{0x1E008, 0x1E018}, {0x1E01B, 0x1E021}, {0x1E023, 0x1E024},
 	{0x1E026, 0x1E02A}, {0x1E100, 0x1E12C}, {0x1E130, 0x1E13D},
 	{0x1E140, 0x1E149}, {0x1E14E, 0x1E14F}, {0x1E2C0, 0x1E2F9},
 	{0x1E2FF, 0x1E2FF}, {0x1E800, 0x1E8C4}, {0x1E8C7, 0x1E8D6},
 	{0x1E900, 0x1E94B}, {0x1E950, 0x1E959}, {0x1E95E, 0x1E95F},
 	{0x1EC71, 0x1ECB4}, {0x1ED01, 0x1ED3D}, {0x1EE00, 0x1EE03},
 	{0x1EE05, 0x1EE1F}, {0x1EE21, 0x1EE22}, {0x1EE24, 0x1EE24},
 	{0x1EE27, 0x1EE27}, {0x1EE29, 0x1EE32}, {0x1EE34, 0x1EE37},
 	{0x1EE39, 0x1EE39}, {0x1EE3B, 0x1EE3B}, {0x1EE42, 0x1EE42},
 	{0x1EE47, 0x1EE47}, {0x1EE49, 0x1EE49}, {0x1EE4B, 0x1EE4B},
 	{0x1EE4D, 0x1EE4F}, {0x1EE51, 0x1EE52}, {0x1EE54, 0x1EE54},
 	{0x1EE57, 0x1EE57}, {0x1EE59, 0x1EE59}, {0x1EE5B, 0x1EE5B},
 	{0x1EE5D, 0x1EE5D}, {0x1EE5F, 0x1EE5F}, {0x1EE61, 0x1EE62},
 	{0x1EE64, 0x1EE64}, {0x1EE67, 0x1EE6A}, {0x1EE6C, 0x1EE72},
 	{0x1EE74, 0x1EE77}, {0x1EE79, 0x1EE7C}, {0x1EE7E, 0x1EE7E},
 	{0x1EE80, 0x1EE89}, {0x1EE8B, 0x1EE9B}, {0x1EEA1, 0x1EEA3},
 	{0x1EEA5, 0x1EEA9}, {0x1EEAB, 0x1EEBB}, {0x1EEF0, 0x1EEF1},
 	{0x1F000, 0x1F003}, {0x1F005, 0x1F02B}, {0x1F030, 0x1F093},
 	{0x1F0A0, 0x1F0AE}, {0x1F0B1, 0x1F0BF}, {0x1F0C1, 0x1F0CE},
 	{0x1F0D1, 0x1F0F5}, {0x1F10B, 0x1F10F}, {0x1F12E, 0x1F12F},
 	{0x1F16A, 0x1F16F}, {0x1F1AD, 0x1F1AD}, {0x1F1E6, 0x1F1FF},
 	{0x1F321, 0x1F32C}, {0x1F336, 0x1F336}, {0x1F37D, 0x1F37D},
 	{0x1F394, 0x1F39F}, {0x1F3CB, 0x1F3CE}, {0x1F3D4, 0x1F3DF},
 	{0x1F3F1, 0x1F3F3}, {0x1F3F5, 0x1F3F7}, {0x1F43F, 0x1F43F},
 	{0x1F441, 0x1F441}, {0x1F4FD, 0x1F4FE}, {0x1F53E, 0x1F54A},
 	{0x1F54F, 0x1F54F}, {0x1F568, 0x1F579}, {0x1F57B, 0x1F594},
 	{0x1F597, 0x1F5A3}, {0x1F5A5, 0x1F5FA}, {0x1F650, 0x1F67F},
 	{0x1F6C6, 0x1F6CB}, {0x1F6CD, 0x1F6CF}, {0x1F6D3, 0x1F6D4},
 	{0x1F6E0, 0x1F6EA}, {0x1F6F0, 0x1F6F3}, {0x1F700, 0x1F773},
 	{0x1F780, 0x1F7D8}, {0x1F800, 0x1F80B}, {0x1F810, 0x1F847},
 	{0x1F850, 0x1F859}, {0x1F860, 0x1F887}, {0x1F890, 0x1F8AD},
 	{0x1F8B0, 0x1F8B1}, {0x1F900, 0x1F90B}, {0x1F93B, 0x1F93B},
 	{0x1F946, 0x1F946}, {0x1FA00, 0x1FA53}, {0x1FA60, 0x1FA6D},
 	{0x1FB00, 0x1FB92}, {0x1FB94, 0x1FBCA}, {0x1FBF0, 0x1FBF9},
 	{0xE0001, 0xE0001}, {0xE0020, 0xE007F},
 }
 var emoji = table{
 	{0x203C, 0x203C}, {0x2049, 0x2049}, {0x2122, 0x2122},
 	{0x2139, 0x2139}, {0x2194, 0x2199}, {0x21A9, 0x21AA},
 	{0x231A, 0x231B}, {0x2328, 0x2328}, {0x2388, 0x2388},
 	{0x23CF, 0x23CF}, {0x23E9, 0x23F3}, {0x23F8, 0x23FA},
 	{0x24C2, 0x24C2}, {0x25AA, 0x25AB}, {0x25B6, 0x25B6},
 	{0x25C0, 0x25C0}, {0x25FB, 0x25FE}, {0x2600, 0x2605},
 	{0x2607, 0x2612}, {0x2614, 0x2685}, {0x2690, 0x2705},
 	{0x2708, 0x2712}, {0x2714, 0x2714}, {0x2716, 0x2716},
 	{0x271D, 0x271D}, {0x2721, 0x2721}, {0x2728, 0x2728},
 	{0x2733, 0x2734}, {0x2744, 0x2744}, {0x2747, 0x2747},
 	{0x274C, 0x274C}, {0x274E, 0x274E}, {0x2753, 0x2755},
 	{0x2757, 0x2757}, {0x2763, 0x2767}, {0x2795, 0x2797},
 	{0x27A1, 0x27A1}, {0x27B0, 0x27B0}, {0x27BF, 0x27BF},
 	{0x2934, 0x2935}, {0x2B05, 0x2B07}, {0x2B1B, 0x2B1C},
 	{0x2B50, 0x2B50}, {0x2B55, 0x2B55}, {0x3030, 0x3030},
 	{0x303D, 0x303D}, {0x3297, 0x3297}, {0x3299, 0x3299},
 	{0x1F000, 0x1F0FF}, {0x1F10D, 0x1F10F}, {0x1F12F, 0x1F12F},
 	{0x1F16C, 0x1F171}, {0x1F17E, 0x1F17F}, {0x1F18E, 0x1F18E},
 	{0x1F191, 0x1F19A}, {0x1F1AD, 0x1F1E5}, {0x1F201, 0x1F20F},
 	{0x1F21A, 0x1F21A}, {0x1F22F, 0x1F22F}, {0x1F232, 0x1F23A},
 	{0x1F23C, 0x1F23F}, {0x1F249, 0x1F3FA}, {0x1F400, 0x1F53D},
 	{0x1F546, 0x1F64F}, {0x1F680, 0x1F6FF}, {0x1F774, 0x1F77F},
 	{0x1F7D5, 0x1F7FF}, {0x1F80C, 0x1F80F}, {0x1F848, 0x1F84F},
 	{0x1F85A, 0x1F85F}, {0x1F888, 0x1F88F}, {0x1F8AE, 0x1F8FF},
 	{0x1F90C, 0x1F93A}, {0x1F93C, 0x1F945}, {0x1F947, 0x1FAFF},
 	{0x1FC00, 0x1FFFD},
 }
--- a/vendor/github.com/mattn/go-runewidth/runewidth_windows.go
+++ b/vendor/github.com/mattn/go-runewidth/runewidth_windows.go
@ -0,0 +1,28 @@
 // +build windows
 // +build !appengine
 package runewidth
 import (
 	"syscall"
 )
 var (
 	kernel32               = syscall.NewLazyDLL("kernel32")
 	procGetConsoleOutputCP = kernel32.NewProc("GetConsoleOutputCP")
 )
 // IsEastAsian return true if the current locale is CJK
 func IsEastAsian() bool {
 	r1, _, _ := procGetConsoleOutputCP.Call()
 	if r1 == 0 {
 		return false
 	}
 	switch int(r1) {
 	case 932, 51932, 936, 949, 950:
 		return true
 	}
 	return false
 }
--- a/vendor/github.com/mitchellh/colorstring/.travis.yml
+++ b/vendor/github.com/mitchellh/colorstring/.travis.yml
@ -0,0 +1,15 @@
 language: go
 go:
    - 1.0
    - 1.1
    - 1.2
    - 1.3
    - tip
 script:
    - go test
 matrix:
    allow_failures:
        - go: tip
--- a/vendor/github.com/mitchellh/colorstring/LICENSE
+++ b/vendor/github.com/mitchellh/colorstring/LICENSE
@ -0,0 +1,21 @@
 The MIT License (MIT)
 Copyright (c) 2014 Mitchell Hashimoto
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
--- a/vendor/github.com/mitchellh/colorstring/README.md
+++ b/vendor/github.com/mitchellh/colorstring/README.md
@ -0,0 +1,30 @@
 # colorstring [![Build Status](https://travis-ci.org/mitchellh/colorstring.svg)](https://travis-ci.org/mitchellh/colorstring)
 colorstring is a [Go](http://www.golang.org) library for outputting colored
 strings to a console using a simple inline syntax in your string to specify
 the color to print as.
 For example, the string `[blue]hello [red]world` would output the text
 "hello world" in two colors. The API of colorstring allows for easily disabling
 colors, adding aliases, etc.
 ## Installation
 Standard `go get`:
 ```
 $ go get github.com/mitchellh/colorstring
 ```
 ## Usage & Example
 For usage and examples see the [Godoc](http://godoc.org/github.com/mitchellh/colorstring).
 Usage is easy enough:
 ```go
 colorstring.Println("[blue]Hello [red]World!")
 ```
 Additionally, the `Colorize` struct can be used to set options such as
 custom colors, color disabling, etc.
--- a/vendor/github.com/mitchellh/colorstring/colorstring.go
+++ b/vendor/github.com/mitchellh/colorstring/colorstring.go
@ -0,0 +1,244 @@
 // colorstring provides functions for colorizing strings for terminal
 // output.
 package colorstring
 import (
 	"bytes"
 	"fmt"
 	"io"
 	"regexp"
 	"strings"
 )
 // Color colorizes your strings using the default settings.
 //
 // Strings given to Color should use the syntax `[color]` to specify the
 // color for text following. For example: `[blue]Hello` will return "Hello"
 // in blue. See DefaultColors for all the supported colors and attributes.
 //
 // If an unrecognized color is given, it is ignored and assumed to be part
 // of the string. For example: `[hi]world` will result in "[hi]world".
 //
 // A color reset is appended to the end of every string. This will reset
 // the color of following strings when you output this text to the same
 // terminal session.
 //
 // If you want to customize any of this behavior, use the Colorize struct.
 func Color(v string) string {
 	return def.Color(v)
 }
 // ColorPrefix returns the color sequence that prefixes the given text.
 //
 // This is useful when wrapping text if you want to inherit the color
 // of the wrapped text. For example, "[green]foo" will return "[green]".
 // If there is no color sequence, then this will return "".
 func ColorPrefix(v string) string {
 	return def.ColorPrefix(v)
 }
 // Colorize colorizes your strings, giving you the ability to customize
 // some of the colorization process.
 //
 // The options in Colorize can be set to customize colorization. If you're
 // only interested in the defaults, just use the top Color function directly,
 // which creates a default Colorize.
 type Colorize struct {
 	// Colors maps a color string to the code for that color. The code
 	// is a string so that you can use more complex colors to set foreground,
 	// background, attributes, etc. For example, "boldblue" might be
 	// "1;34"
 	Colors map[string]string
 	// If true, color attributes will be ignored. This is useful if you're
 	// outputting to a location that doesn't support colors and you just
 	// want the strings returned.
 	Disable bool
 	// Reset, if true, will reset the color after each colorization by
 	// adding a reset code at the end.
 	Reset bool
 }
 // Color colorizes a string according to the settings setup in the struct.
 //
 // For more details on the syntax, see the top-level Color function.
 func (c *Colorize) Color(v string) string {
 	matches := parseRe.FindAllStringIndex(v, -1)
 	if len(matches) == 0 {
 		return v
 	}
 	result := new(bytes.Buffer)
 	colored := false
 	m := []int{0, 0}
 	for _, nm := range matches {
 		// Write the text in between this match and the last
 		result.WriteString(v[m[1]:nm[0]])
 		m = nm
 		var replace string
 		if code, ok := c.Colors[v[m[0]+1:m[1]-1]]; ok {
 			colored = true
 			if !c.Disable {
 				replace = fmt.Sprintf("\033[%sm", code)
 			}
 		} else {
 			replace = v[m[0]:m[1]]
 		}
 		result.WriteString(replace)
 	}
 	result.WriteString(v[m[1]:])
 	if colored && c.Reset && !c.Disable {
 		// Write the clear byte at the end
 		result.WriteString("\033[0m")
 	}
 	return result.String()
 }
 // ColorPrefix returns the first color sequence that exists in this string.
 //
 // For example: "[green]foo" would return "[green]". If no color sequence
 // exists, then "" is returned. This is especially useful when wrapping
 // colored texts to inherit the color of the wrapped text.
 func (c *Colorize) ColorPrefix(v string) string {
 	return prefixRe.FindString(strings.TrimSpace(v))
 }
 // DefaultColors are the default colors used when colorizing.
 //
 // If the color is surrounded in underscores, such as "_blue_", then that
 // color will be used for the background color.
 var DefaultColors map[string]string
 func init() {
 	DefaultColors = map[string]string{
 		// Default foreground/background colors
 		"default":   "39",
 		"_default_": "49",
 		// Foreground colors
 		"black":         "30",
 		"red":           "31",
 		"green":         "32",
 		"yellow":        "33",
 		"blue":          "34",
 		"magenta":       "35",
 		"cyan":          "36",
 		"light_gray":    "37",
 		"dark_gray":     "90",
 		"light_red":     "91",
 		"light_green":   "92",
 		"light_yellow":  "93",
 		"light_blue":    "94",
 		"light_magenta": "95",
 		"light_cyan":    "96",
 		"white":         "97",
 		// Background colors
 		"_black_":         "40",
 		"_red_":           "41",
 		"_green_":         "42",
 		"_yellow_":        "43",
 		"_blue_":          "44",
 		"_magenta_":       "45",
 		"_cyan_":          "46",
 		"_light_gray_":    "47",
 		"_dark_gray_":     "100",
 		"_light_red_":     "101",
 		"_light_green_":   "102",
 		"_light_yellow_":  "103",
 		"_light_blue_":    "104",
 		"_light_magenta_": "105",
 		"_light_cyan_":    "106",
 		"_white_":         "107",
 		// Attributes
 		"bold":       "1",
 		"dim":        "2",
 		"underline":  "4",
 		"blink_slow": "5",
 		"blink_fast": "6",
 		"invert":     "7",
 		"hidden":     "8",
 		// Reset to reset everything to their defaults
 		"reset":      "0",
 		"reset_bold": "21",
 	}
 	def = Colorize{
 		Colors: DefaultColors,
 		Reset:  true,
 	}
 }
 var def Colorize
 var parseReRaw = `\[[a-z0-9_-]+\]`
 var parseRe = regexp.MustCompile(`(?i)` + parseReRaw)
 var prefixRe = regexp.MustCompile(`^(?i)(` + parseReRaw + `)+`)
 // Print is a convenience wrapper for fmt.Print with support for color codes.
 //
 // Print formats using the default formats for its operands and writes to
 // standard output with support for color codes. Spaces are added between
 // operands when neither is a string. It returns the number of bytes written
 // and any write error encountered.
 func Print(a string) (n int, err error) {
 	return fmt.Print(Color(a))
 }
 // Println is a convenience wrapper for fmt.Println with support for color
 // codes.
 //
 // Println formats using the default formats for its operands and writes to
 // standard output with support for color codes. Spaces are always added
 // between operands and a newline is appended. It returns the number of bytes
 // written and any write error encountered.
 func Println(a string) (n int, err error) {
 	return fmt.Println(Color(a))
 }
 // Printf is a convenience wrapper for fmt.Printf with support for color codes.
 //
 // Printf formats according to a format specifier and writes to standard output
 // with support for color codes. It returns the number of bytes written and any
 // write error encountered.
 func Printf(format string, a ...interface{}) (n int, err error) {
 	return fmt.Printf(Color(format), a...)
 }
 // Fprint is a convenience wrapper for fmt.Fprint with support for color codes.
 //
 // Fprint formats using the default formats for its operands and writes to w
 // with support for color codes. Spaces are added between operands when neither
 // is a string. It returns the number of bytes written and any write error
 // encountered.
 func Fprint(w io.Writer, a string) (n int, err error) {
 	return fmt.Fprint(w, Color(a))
 }
 // Fprintln is a convenience wrapper for fmt.Fprintln with support for color
 // codes.
 //
 // Fprintln formats using the default formats for its operands and writes to w
 // with support for color codes. Spaces are always added between operands and a
 // newline is appended. It returns the number of bytes written and any write
 // error encountered.
 func Fprintln(w io.Writer, a string) (n int, err error) {
 	return fmt.Fprintln(w, Color(a))
 }
 // Fprintf is a convenience wrapper for fmt.Fprintf with support for color
 // codes.
 //
 // Fprintf formats according to a format specifier and writes to w with support
 // for color codes. It returns the number of bytes written and any write error
 // encountered.
 func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
 	return fmt.Fprintf(w, Color(format), a...)
 }
--- a/vendor/github.com/mitchellh/colorstring/go.mod
+++ b/vendor/github.com/mitchellh/colorstring/go.mod
@ -0,0 +1 @@
 module github.com/mitchellh/colorstring
--- a/vendor/github.com/rivo/uniseg/LICENSE.txt
+++ b/vendor/github.com/rivo/uniseg/LICENSE.txt
@ -0,0 +1,21 @@
 MIT License
 Copyright (c) 2019 Oliver Kuederle
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
--- a/vendor/github.com/rivo/uniseg/README.md
+++ b/vendor/github.com/rivo/uniseg/README.md
@ -0,0 +1,62 @@
 # Unicode Text Segmentation for Go
 [![Godoc Reference](https://img.shields.io/badge/godoc-reference-blue.svg)](https://godoc.org/github.com/rivo/uniseg)
 [![Go Report](https://img.shields.io/badge/go%20report-A%2B-brightgreen.svg)](https://goreportcard.com/report/github.com/rivo/uniseg)
 This Go package implements Unicode Text Segmentation according to [Unicode Standard Annex #29](http://unicode.org/reports/tr29/) (Unicode version 12.0.0).
 At this point, only the determination of grapheme cluster boundaries is implemented.
 ## Background
 In Go, [strings are read-only slices of bytes](https://blog.golang.org/strings). They can be turned into Unicode code points using the `for` loop or by casting: `[]rune(str)`. However, multiple code points may be combined into one user-perceived character or what the Unicode specification calls "grapheme cluster". Here are some examples:
 |String|Bytes (UTF-8)|Code points (runes)|Grapheme clusters|
 |-|-|-|-|
 |Käse|6 bytes: `4b 61 cc 88 73 65`|5 code points: `4b 61 308 73 65`|4 clusters: `[4b],[61 308],[73],[65]`|
 |🏳️‍🌈|14 bytes: `f0 9f 8f b3 ef b8 8f e2 80 8d f0 9f 8c 88`|4 code points: `1f3f3 fe0f 200d 1f308`|1 cluster: `[1f3f3 fe0f 200d 1f308]`|
 |🇩🇪|8 bytes: `f0 9f 87 a9 f0 9f 87 aa`|2 code points: `1f1e9 1f1ea`|1 cluster: `[1f1e9 1f1ea]`|
 This package provides a tool to iterate over these grapheme clusters. This may be used to determine the number of user-perceived characters, to split strings in their intended places, or to extract individual characters which form a unit.
 ## Installation
 ```bash
 go get github.com/rivo/uniseg
 ```
 ## Basic Example
 ```go
 package uniseg
 import (
 	"fmt"
 	"github.com/rivo/uniseg"
 )
 func main() {
 	gr := uniseg.NewGraphemes("👍🏼!")
 	for gr.Next() {
 		fmt.Printf("%x ", gr.Runes())
 	}
 	// Output: [1f44d 1f3fc] [21]
 }
 ```
 ## Documentation
 Refer to https://godoc.org/github.com/rivo/uniseg for the package's documentation.
 ## Dependencies
 This package does not depend on any packages outside the standard library.
 ## Your Feedback
 Add your issue here on GitHub. Feel free to get in touch if you have any questions.
 ## Version
 Version tags will be introduced once Golang modules are official. Consider this version 0.1.
--- a/vendor/github.com/rivo/uniseg/doc.go
+++ b/vendor/github.com/rivo/uniseg/doc.go
@ -0,0 +1,8 @@
 /*
 Package uniseg implements Unicode Text Segmentation according to Unicode
 Standard Annex #29 (http://unicode.org/reports/tr29/).
 At this point, only the determination of grapheme cluster boundaries is
 implemented.
 */
 package uniseg
--- a/vendor/github.com/rivo/uniseg/go.mod
+++ b/vendor/github.com/rivo/uniseg/go.mod
@ -0,0 +1,3 @@
 module github.com/rivo/uniseg
 go 1.12
--- a/vendor/github.com/rivo/uniseg/grapheme.go
+++ b/vendor/github.com/rivo/uniseg/grapheme.go
@ -0,0 +1,268 @@
 package uniseg
 import "unicode/utf8"
 // The states of the grapheme cluster parser.
 const (
 	grAny = iota
 	grCR
 	grControlLF
 	grL
 	grLVV
 	grLVTT
 	grPrepend
 	grExtendedPictographic
 	grExtendedPictographicZWJ
 	grRIOdd
 	grRIEven
 )
 // The grapheme cluster parser's breaking instructions.
 const (
 	grNoBoundary = iota
 	grBoundary
 )
 // The grapheme cluster parser's state transitions. Maps (state, property) to
 // (new state, breaking instruction, rule number). The breaking instruction
 // always refers to the boundary between the last and next code point.
 //
 // This map is queried as follows:
 //
 //   1. Find specific state + specific property. Stop if found.
 //   2. Find specific state + any property.
 //   3. Find any state + specific property.
 //   4. If only (2) or (3) (but not both) was found, stop.
 //   5. If both (2) and (3) were found, use state and breaking instruction from
 //      the transition with the lower rule number, prefer (3) if rule numbers
 //      are equal. Stop.
 //   6. Assume grAny and grBoundary.
 var grTransitions = map[[2]int][3]int{
 	// GB5
 	{grAny, prCR}:      {grCR, grBoundary, 50},
 	{grAny, prLF}:      {grControlLF, grBoundary, 50},
 	{grAny, prControl}: {grControlLF, grBoundary, 50},
 	// GB4
 	{grCR, prAny}:        {grAny, grBoundary, 40},
 	{grControlLF, prAny}: {grAny, grBoundary, 40},
 	// GB3.
 	{grCR, prLF}: {grAny, grNoBoundary, 30},
 	// GB6.
 	{grAny, prL}: {grL, grBoundary, 9990},
 	{grL, prL}:   {grL, grNoBoundary, 60},
 	{grL, prV}:   {grLVV, grNoBoundary, 60},
 	{grL, prLV}:  {grLVV, grNoBoundary, 60},
 	{grL, prLVT}: {grLVTT, grNoBoundary, 60},
 	// GB7.
 	{grAny, prLV}: {grLVV, grBoundary, 9990},
 	{grAny, prV}:  {grLVV, grBoundary, 9990},
 	{grLVV, prV}:  {grLVV, grNoBoundary, 70},
 	{grLVV, prT}:  {grLVTT, grNoBoundary, 70},
 	// GB8.
 	{grAny, prLVT}: {grLVTT, grBoundary, 9990},
 	{grAny, prT}:   {grLVTT, grBoundary, 9990},
 	{grLVTT, prT}:  {grLVTT, grNoBoundary, 80},
 	// GB9.
 	{grAny, prExtend}: {grAny, grNoBoundary, 90},
 	{grAny, prZWJ}:    {grAny, grNoBoundary, 90},
 	// GB9a.
 	{grAny, prSpacingMark}: {grAny, grNoBoundary, 91},
 	// GB9b.
 	{grAny, prPreprend}: {grPrepend, grBoundary, 9990},
 	{grPrepend, prAny}:  {grAny, grNoBoundary, 92},
 	// GB11.
 	{grAny, prExtendedPictographic}:                     {grExtendedPictographic, grBoundary, 9990},
 	{grExtendedPictographic, prExtend}:                  {grExtendedPictographic, grNoBoundary, 110},
 	{grExtendedPictographic, prZWJ}:                     {grExtendedPictographicZWJ, grNoBoundary, 110},
 	{grExtendedPictographicZWJ, prExtendedPictographic}: {grExtendedPictographic, grNoBoundary, 110},
 	// GB12 / GB13.
 	{grAny, prRegionalIndicator}:    {grRIOdd, grBoundary, 9990},
 	{grRIOdd, prRegionalIndicator}:  {grRIEven, grNoBoundary, 120},
 	{grRIEven, prRegionalIndicator}: {grRIOdd, grBoundary, 120},
 }
 // Graphemes implements an iterator over Unicode extended grapheme clusters,
 // specified in the Unicode Standard Annex #29. Grapheme clusters correspond to
 // "user-perceived characters". These characters often consist of multiple
 // code points (e.g. the "woman kissing woman" emoji consists of 8 code points:
 // woman + ZWJ + heavy black heart (2 code points) + ZWJ + kiss mark + ZWJ +
 // woman) and the rules described in Annex #29 must be applied to group those
 // code points into clusters perceived by the user as one character.
 type Graphemes struct {
 	// The code points over which this class iterates.
 	codePoints []rune
 	// The (byte-based) indices of the code points into the original string plus
 	// len(original string). Thus, len(indices) = len(codePoints) + 1.
 	indices []int
 	// The current grapheme cluster to be returned. These are indices into
 	// codePoints/indices. If start == end, we either haven't started iterating
 	// yet (0) or the iteration has already completed (1).
 	start, end int
 	// The index of the next code point to be parsed.
 	pos int
 	// The current state of the code point parser.
 	state int
 }
 // NewGraphemes returns a new grapheme cluster iterator.
 func NewGraphemes(s string) *Graphemes {
 	l := utf8.RuneCountInString(s)
 	codePoints := make([]rune, l)
 	indices := make([]int, l+1)
 	i := 0
 	for pos, r := range s {
 		codePoints[i] = r
 		indices[i] = pos
 		i++
 	}
 	indices[l] = len(s)
 	g := &Graphemes{
 		codePoints: codePoints,
 		indices:    indices,
 	}
 	g.Next() // Parse ahead.
 	return g
 }
 // Next advances the iterator by one grapheme cluster and returns false if no
 // clusters are left. This function must be called before the first cluster is
 // accessed.
 func (g *Graphemes) Next() bool {
 	g.start = g.end
 	// The state transition gives us a boundary instruction BEFORE the next code
 	// point so we always need to stay ahead by one code point.
 	// Parse the next code point.
 	for g.pos <= len(g.codePoints) {
 		// GB2.
 		if g.pos == len(g.codePoints) {
 			g.end = g.pos
 			g.pos++
 			break
 		}
 		// Determine the property of the next character.
 		nextProperty := property(g.codePoints[g.pos])
 		g.pos++
 		// Find the applicable transition.
 		var boundary bool
 		transition, ok := grTransitions[[2]int{g.state, nextProperty}]
 		if ok {
 			// We have a specific transition. We'll use it.
 			g.state = transition[0]
 			boundary = transition[1] == grBoundary
 		} else {
 			// No specific transition found. Try the less specific ones.
 			transAnyProp, okAnyProp := grTransitions[[2]int{g.state, prAny}]
 			transAnyState, okAnyState := grTransitions[[2]int{grAny, nextProperty}]
 			if okAnyProp && okAnyState {
 				// Both apply. We'll use a mix (see comments for grTransitions).
 				g.state = transAnyState[0]
 				boundary = transAnyState[1] == grBoundary
 				if transAnyProp[2] < transAnyState[2] {
 					g.state = transAnyProp[0]
 					boundary = transAnyProp[1] == grBoundary
 				}
 			} else if okAnyProp {
 				// We only have a specific state.
 				g.state = transAnyProp[0]
 				boundary = transAnyProp[1] == grBoundary
 				// This branch will probably never be reached because okAnyState will
 				// always be true given the current transition map. But we keep it here
 				// for future modifications to the transition map where this may not be
 				// true anymore.
 			} else if okAnyState {
 				// We only have a specific property.
 				g.state = transAnyState[0]
 				boundary = transAnyState[1] == grBoundary
 			} else {
 				// No known transition. GB999: Any x Any.
 				g.state = grAny
 				boundary = true
 			}
 		}
 		// If we found a cluster boundary, let's stop here. The current cluster will
 		// be the one that just ended.
 		if g.pos-1 == 0 /* GB1 */ || boundary {
 			g.end = g.pos - 1
 			break
 		}
 	}
 	return g.start != g.end
 }
 // Runes returns a slice of runes (code points) which corresponds to the current
 // grapheme cluster. If the iterator is already past the end or Next() has not
 // yet been called, nil is returned.
 func (g *Graphemes) Runes() []rune {
 	if g.start == g.end {
 		return nil
 	}
 	return g.codePoints[g.start:g.end]
 }
 // Str returns a substring of the original string which corresponds to the
 // current grapheme cluster. If the iterator is already past the end or Next()
 // has not yet been called, an empty string is returned.
 func (g *Graphemes) Str() string {
 	if g.start == g.end {
 		return ""
 	}
 	return string(g.codePoints[g.start:g.end])
 }
 // Bytes returns a byte slice which corresponds to the current grapheme cluster.
 // If the iterator is already past the end or Next() has not yet been called,
 // nil is returned.
 func (g *Graphemes) Bytes() []byte {
 	if g.start == g.end {
 		return nil
 	}
 	return []byte(string(g.codePoints[g.start:g.end]))
 }
 // Positions returns the interval of the current grapheme cluster as byte
 // positions into the original string. The first returned value "from" indexes
 // the first byte and the second returned value "to" indexes the first byte that
 // is not included anymore, i.e. str[from:to] is the current grapheme cluster of
 // the original string "str". If Next() has not yet been called, both values are
 // 0. If the iterator is already past the end, both values are 1.
 func (g *Graphemes) Positions() (int, int) {
 	return g.indices[g.start], g.indices[g.end]
 }
 // Reset puts the iterator into its initial state such that the next call to
 // Next() sets it to the first grapheme cluster again.
 func (g *Graphemes) Reset() {
 	g.start, g.end, g.pos, g.state = 0, 0, 0, grAny
 	g.Next() // Parse ahead again.
 }
 // GraphemeClusterCount returns the number of user-perceived characters
 // (grapheme clusters) for the given string. To calculate this number, it
 // iterates through the string using the Graphemes iterator.
 func GraphemeClusterCount(s string) (n int) {
 	g := NewGraphemes(s)
 	for g.Next() {
 		n++
 	}
 	return
 }
--- a/vendor/github.com/rivo/uniseg/properties.go
+++ b/vendor/github.com/rivo/uniseg/properties.go
--- a/vendor/github.com/schollz/progressbar/v3/.gitignore
+++ b/vendor/github.com/schollz/progressbar/v3/.gitignore
@ -0,0 +1,18 @@
 # Binaries for programs and plugins
 *.exe
 *.exe~
 *.dll
 *.so
 *.dylib
 # Test binary, built with `go test -c`
 *.test
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 # Dependency directories (remove the comment below to include it)
 # vendor/
 .idea/
 *.tar.gz
--- a/vendor/github.com/schollz/progressbar/v3/.travis.yml
+++ b/vendor/github.com/schollz/progressbar/v3/.travis.yml
@ -0,0 +1,6 @@
 language: go
 go:
  - tip
 script: go test -v .
--- a/vendor/github.com/schollz/progressbar/v3/LICENSE
+++ b/vendor/github.com/schollz/progressbar/v3/LICENSE
@ -0,0 +1,21 @@
 MIT License
 Copyright (c) 2017 Zack
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
--- a/vendor/github.com/schollz/progressbar/v3/README.md
+++ b/vendor/github.com/schollz/progressbar/v3/README.md
@ -0,0 +1,121 @@
 # progressbar
 [![travis](https://travis-ci.org/schollz/progressbar.svg?branch=master)](https://travis-ci.org/schollz/progressbar) 
 [![go report card](https://goreportcard.com/badge/github.com/schollz/progressbar)](https://goreportcard.com/report/github.com/schollz/progressbar) 
 [![coverage](https://img.shields.io/badge/coverage-84%25-brightgreen.svg)](https://gocover.io/github.com/schollz/progressbar)
 [![godocs](https://godoc.org/github.com/schollz/progressbar?status.svg)](https://godoc.org/github.com/schollz/progressbar/v3) 
 A very simple thread-safe progress bar which should work on every OS without problems. I needed a progressbar for [croc](https://github.com/schollz/croc) and everything I tried had problems, so I made another one. In order to be OS agnostic I do not plan to support [multi-line outputs](https://github.com/schollz/progressbar/issues/6).
 ## Install
 ```
 go get -u github.com/schollz/progressbar/v3
 ```
 ## Usage 
 ### Basic usage
 ```golang
 bar := progressbar.Default(100)
 for i := 0; i < 100; i++ {
    bar.Add(1)
    time.Sleep(40 * time.Millisecond)
 }
 ```
 which looks like:
 ![Example of basic bar](examples/basic/basic.gif)
 ### I/O operations
 The `progressbar` implements an `io.Writer` so it can automatically detect the number of bytes written to a stream, so you can use it as a progressbar for an `io.Reader`.
 ```golang
 req, _ := http.NewRequest("GET", "https://dl.google.com/go/go1.14.2.src.tar.gz", nil)
 resp, _ := http.DefaultClient.Do(req)
 defer resp.Body.Close()
 f, _ := os.OpenFile("go1.14.2.src.tar.gz", os.O_CREATE|os.O_WRONLY, 0644)
 defer f.Close()
 bar := progressbar.DefaultBytes(
    resp.ContentLength,
    "downloading",
 )
 io.Copy(io.MultiWriter(f, bar), resp.Body)
 ```
 which looks like:
 ![Example of download bar](examples/download/download.gif)
 ### Progress bar with unknown length
 A progressbar with unknown length is a spinner. Any bar with -1 length will automatically convert it to a spinner with a customizable spinner type. For example, the above code can be run and set the `resp.ContentLength` to `-1`.
 which looks like:
 ![Example of download bar with unknown length](examples/download-unknown/download-unknown.gif)
 ### Customization
 There is a lot of customization that you can do - change the writer, the color, the width, description, theme, etc. See [all the options](https://pkg.go.dev/github.com/schollz/progressbar/v3?tab=doc#Option).
 ```golang
 bar := progressbar.NewOptions(1000,
    progressbar.OptionSetWriter(ansi.NewAnsiStdout()),
    progressbar.OptionEnableColorCodes(true),
    progressbar.OptionShowBytes(true),
    progressbar.OptionSetWidth(15),
    progressbar.OptionSetDescription("[cyan][1/3][reset] Writing moshable file..."),
    progressbar.OptionSetTheme(progressbar.Theme{
        Saucer:        "[green]=[reset]",
        SaucerHead:    "[green]>[reset]",
        SaucerPadding: " ",
        BarStart:      "[",
        BarEnd:        "]",
    }))
 for i := 0; i < 1000; i++ {
    bar.Add(1)
    time.Sleep(5 * time.Millisecond)
 }
 ```
 which looks like:
 ![Example of customized bar](examples/customization/customization.gif)
 ## Contributing
 Pull requests are welcome. Feel free to...
 - Revise documentation
 - Add new features
 - Fix bugs
 - Suggest improvements
 ## Thanks
 Thanks [@Dynom](https://github.com/dynom) for massive improvements in version 2.0!
 Thanks [@CrushedPixel](https://github.com/CrushedPixel) for adding descriptions and color code support!
 Thanks [@MrMe42](https://github.com/MrMe42) for adding some minor features!
 Thanks [@tehstun](https://github.com/tehstun) for some great PRs!
 Thanks [@Benzammour](https://github.com/Benzammour) and [@haseth](https://github.com/haseth) for helping create v3!
 Thanks [@briandowns](https://github.com/briandowns) for compiling the list of spinners.
 ## License
 MIT
--- a/vendor/github.com/schollz/progressbar/v3/go.mod
+++ b/vendor/github.com/schollz/progressbar/v3/go.mod
@ -0,0 +1,15 @@
 module github.com/schollz/progressbar/v3
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/k0kubun/go-ansi v0.0.0-20180517002512-3bf9e2903213
 	github.com/mattn/go-isatty v0.0.13 // indirect
 	github.com/mattn/go-runewidth v0.0.13
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db
 	github.com/stretchr/testify v1.3.0
 	golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e
 	golang.org/x/sys v0.0.0-20210616094352-59db8d763f22 // indirect
 	golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b // indirect
 )
 go 1.13
--- a/vendor/github.com/schollz/progressbar/v3/go.sum
+++ b/vendor/github.com/schollz/progressbar/v3/go.sum
@ -0,0 +1,31 @@
 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/k0kubun/go-ansi v0.0.0-20180517002512-3bf9e2903213 h1:qGQQKEcAR99REcMpsXCp3lJ03zYT1PkRd3kQGPn9GVg=
 github.com/k0kubun/go-ansi v0.0.0-20180517002512-3bf9e2903213/go.mod h1:vNUNkEQ1e29fT/6vq2aBdFsgNPmy8qMdSay1npru+Sw=
 github.com/mattn/go-isatty v0.0.13 h1:qdl+GuBjcsKKDco5BsxPJlId98mSWNKqYA+Co0SC1yA=
 github.com/mattn/go-isatty v0.0.13/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU=
 github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db h1:62I3jR2EmQ4l5rM/4FEfDWcRD+abF5XlKShorW5LRoQ=
 github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw=
 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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 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/crypto v0.0.0-20210616213533-5ff15b29337e h1:gsTQYXdTw2Gq7RBsWvlQ91b+aEQ6bXFUngBGuR8sPpI=
 golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22 h1:RqytpXGR1iVNX7psjB3ff8y7sNFinVFvkx1c8SjBkio=
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b h1:9zKuko04nR4gjZ4+DNjHqRlAJqbJETHwiNKDqTfOjfE=
 golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
--- a/vendor/github.com/schollz/progressbar/v3/progressbar.go
+++ b/vendor/github.com/schollz/progressbar/v3/progressbar.go
@ -0,0 +1,927 @@
 package progressbar
 import (
 	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"math"
 	"os"
 	"regexp"
 	"strings"
 	"sync"
 	"time"
 	"github.com/mattn/go-runewidth"
 	"github.com/mitchellh/colorstring"
 	"golang.org/x/crypto/ssh/terminal"
 )
 // ProgressBar is a thread-safe, simple
 // progress bar
 type ProgressBar struct {
 	state  state
 	config config
 	lock   sync.Mutex
 }
 // State is the basic properties of the bar
 type State struct {
 	CurrentPercent float64
 	CurrentBytes   float64
 	SecondsSince   float64
 	SecondsLeft    float64
 	KBsPerSecond   float64
 }
 type state struct {
 	currentNum        int64
 	currentPercent    int
 	lastPercent       int
 	currentSaucerSize int
 	lastShown time.Time
 	startTime time.Time
 	counterTime         time.Time
 	counterNumSinceLast int64
 	counterLastTenRates []float64
 	maxLineWidth int
 	currentBytes float64
 	finished     bool
 	rendered string
 }
 type config struct {
 	max                  int64 // max number of the counter
 	maxHumanized         string
 	maxHumanizedSuffix   string
 	width                int
 	writer               io.Writer
 	theme                Theme
 	renderWithBlankState bool
 	description          string
 	iterationString      string
 	ignoreLength         bool // ignoreLength if max bytes not known
 	// whether the output is expected to contain color codes
 	colorCodes bool
 	// show rate of change in kB/sec or MB/sec
 	showBytes bool
 	// show the iterations per second
 	showIterationsPerSecond bool
 	showIterationsCount     bool
 	// whether the progress bar should attempt to predict the finishing
 	// time of the progress based on the start time and the average
 	// number of seconds between  increments.
 	predictTime bool
 	// minimum time to wait in between updates
 	throttleDuration time.Duration
 	// clear bar once finished
 	clearOnFinish bool
 	// spinnerType should be a number between 0-75
 	spinnerType int
 	// fullWidth specifies whether to measure and set the bar to a specific width
 	fullWidth bool
 	// invisible doesn't render the bar at all, useful for debugging
 	invisible bool
 	onCompletion func()
 	// whether the render function should make use of ANSI codes to reduce console I/O
 	useANSICodes bool
 }
 // Theme defines the elements of the bar
 type Theme struct {
 	Saucer        string
 	SaucerHead    string
 	SaucerPadding string
 	BarStart      string
 	BarEnd        string
 }
 // Option is the type all options need to adhere to
 type Option func(p *ProgressBar)
 // OptionSetWidth sets the width of the bar
 func OptionSetWidth(s int) Option {
 	return func(p *ProgressBar) {
 		p.config.width = s
 	}
 }
 // OptionSpinnerType sets the type of spinner used for indeterminate bars
 func OptionSpinnerType(spinnerType int) Option {
 	return func(p *ProgressBar) {
 		p.config.spinnerType = spinnerType
 	}
 }
 // OptionSetTheme sets the elements the bar is constructed of
 func OptionSetTheme(t Theme) Option {
 	return func(p *ProgressBar) {
 		p.config.theme = t
 	}
 }
 // OptionSetVisibility sets the visibility
 func OptionSetVisibility(visibility bool) Option {
 	return func(p *ProgressBar) {
 		p.config.invisible = !visibility
 	}
 }
 // OptionFullWidth sets the bar to be full width
 func OptionFullWidth() Option {
 	return func(p *ProgressBar) {
 		p.config.fullWidth = true
 	}
 }
 // OptionSetWriter sets the output writer (defaults to os.StdOut)
 func OptionSetWriter(w io.Writer) Option {
 	return func(p *ProgressBar) {
 		p.config.writer = w
 	}
 }
 // OptionSetRenderBlankState sets whether or not to render a 0% bar on construction
 func OptionSetRenderBlankState(r bool) Option {
 	return func(p *ProgressBar) {
 		p.config.renderWithBlankState = r
 	}
 }
 // OptionSetDescription sets the description of the bar to render in front of it
 func OptionSetDescription(description string) Option {
 	return func(p *ProgressBar) {
 		p.config.description = description
 	}
 }
 // OptionEnableColorCodes enables or disables support for color codes
 // using mitchellh/colorstring
 func OptionEnableColorCodes(colorCodes bool) Option {
 	return func(p *ProgressBar) {
 		p.config.colorCodes = colorCodes
 	}
 }
 // OptionSetPredictTime will also attempt to predict the time remaining.
 func OptionSetPredictTime(predictTime bool) Option {
 	return func(p *ProgressBar) {
 		p.config.predictTime = predictTime
 	}
 }
 // OptionShowCount will also print current count out of total
 func OptionShowCount() Option {
 	return func(p *ProgressBar) {
 		p.config.showIterationsCount = true
 	}
 }
 // OptionShowIts will also print the iterations/second
 func OptionShowIts() Option {
 	return func(p *ProgressBar) {
 		p.config.showIterationsPerSecond = true
 	}
 }
 // OptionSetItsString sets what's displayed for interations a second. The default is "it" which would display: "it/s"
 func OptionSetItsString(iterationString string) Option {
 	return func(p *ProgressBar) {
 		p.config.iterationString = iterationString
 	}
 }
 // OptionThrottle will wait the specified duration before updating again. The default
 // duration is 0 seconds.
 func OptionThrottle(duration time.Duration) Option {
 	return func(p *ProgressBar) {
 		p.config.throttleDuration = duration
 	}
 }
 // OptionClearOnFinish will clear the bar once its finished
 func OptionClearOnFinish() Option {
 	return func(p *ProgressBar) {
 		p.config.clearOnFinish = true
 	}
 }
 // OptionOnCompletion will invoke cmpl function once its finished
 func OptionOnCompletion(cmpl func()) Option {
 	return func(p *ProgressBar) {
 		p.config.onCompletion = cmpl
 	}
 }
 // OptionShowBytes will update the progress bar
 // configuration settings to display/hide kBytes/Sec
 func OptionShowBytes(val bool) Option {
 	return func(p *ProgressBar) {
 		p.config.showBytes = val
 	}
 }
 // OptionUseANSICodes will use more optimized terminal i/o.
 //
 // Only useful in environments with support for ANSI escape sequences.
 func OptionUseANSICodes(val bool) Option {
 	return func(p *ProgressBar) {
 		p.config.useANSICodes = val
 	}
 }
 var defaultTheme = Theme{Saucer: "█", SaucerPadding: " ", BarStart: "|", BarEnd: "|"}
 // NewOptions constructs a new instance of ProgressBar, with any options you specify
 func NewOptions(max int, options ...Option) *ProgressBar {
 	return NewOptions64(int64(max), options...)
 }
 // NewOptions64 constructs a new instance of ProgressBar, with any options you specify
 func NewOptions64(max int64, options ...Option) *ProgressBar {
 	b := ProgressBar{
 		state: getBasicState(),
 		config: config{
 			writer:           os.Stdout,
 			theme:            defaultTheme,
 			iterationString:  "it",
 			width:            40,
 			max:              max,
 			throttleDuration: 0 * time.Nanosecond,
 			predictTime:      true,
 			spinnerType:      9,
 			invisible:        false,
 		},
 	}
 	for _, o := range options {
 		o(&b)
 	}
 	if b.config.spinnerType < 0 || b.config.spinnerType > 75 {
 		panic("invalid spinner type, must be between 0 and 75")
 	}
 	// ignoreLength if max bytes not known
 	if b.config.max == -1 {
 		b.config.ignoreLength = true
 		b.config.max = int64(b.config.width)
 		b.config.predictTime = false
 	}
 	b.config.maxHumanized, b.config.maxHumanizedSuffix = humanizeBytes(float64(b.config.max))
 	if b.config.renderWithBlankState {
 		b.RenderBlank()
 	}
 	return &b
 }
 func getBasicState() state {
 	now := time.Now()
 	return state{
 		startTime:   now,
 		lastShown:   now,
 		counterTime: now,
 	}
 }
 // New returns a new ProgressBar
 // with the specified maximum
 func New(max int) *ProgressBar {
 	return NewOptions(max)
 }
 // DefaultBytes provides a progressbar to measure byte
 // throughput with recommended defaults.
 // Set maxBytes to -1 to use as a spinner.
 func DefaultBytes(maxBytes int64, description ...string) *ProgressBar {
 	desc := ""
 	if len(description) > 0 {
 		desc = description[0]
 	}
 	bar := NewOptions64(
 		maxBytes,
 		OptionSetDescription(desc),
 		OptionSetWriter(os.Stderr),
 		OptionShowBytes(true),
 		OptionSetWidth(10),
 		OptionThrottle(65*time.Millisecond),
 		OptionShowCount(),
 		OptionOnCompletion(func() {
 			fmt.Fprint(os.Stderr, "\n")
 		}),
 		OptionSpinnerType(14),
 		OptionFullWidth(),
 	)
 	bar.RenderBlank()
 	return bar
 }
 // DefaultBytesSilent is the same as DefaultBytes, but does not output anywhere.
 // String() can be used to get the output instead.
 func DefaultBytesSilent(maxBytes int64, description ...string) *ProgressBar {
 	// Mostly the same bar as DefaultBytes
 	desc := ""
 	if len(description) > 0 {
 		desc = description[0]
 	}
 	bar := NewOptions64(
 		maxBytes,
 		OptionSetDescription(desc),
 		OptionSetWriter(ioutil.Discard),
 		OptionShowBytes(true),
 		OptionSetWidth(10),
 		OptionThrottle(65*time.Millisecond),
 		OptionShowCount(),
 		OptionSpinnerType(14),
 		OptionFullWidth(),
 	)
 	bar.RenderBlank()
 	return bar
 }
 // Default provides a progressbar with recommended defaults.
 // Set max to -1 to use as a spinner.
 func Default(max int64, description ...string) *ProgressBar {
 	desc := ""
 	if len(description) > 0 {
 		desc = description[0]
 	}
 	bar := NewOptions64(
 		max,
 		OptionSetDescription(desc),
 		OptionSetWriter(os.Stderr),
 		OptionSetWidth(10),
 		OptionThrottle(65*time.Millisecond),
 		OptionShowCount(),
 		OptionShowIts(),
 		OptionOnCompletion(func() {
 			fmt.Fprint(os.Stderr, "\n")
 		}),
 		OptionSpinnerType(14),
 		OptionFullWidth(),
 	)
 	bar.RenderBlank()
 	return bar
 }
 // DefaultSilent is the same as Default, but does not output anywhere.
 // String() can be used to get the output instead.
 func DefaultSilent(max int64, description ...string) *ProgressBar {
 	// Mostly the same bar as Default
 	desc := ""
 	if len(description) > 0 {
 		desc = description[0]
 	}
 	bar := NewOptions64(
 		max,
 		OptionSetDescription(desc),
 		OptionSetWriter(ioutil.Discard),
 		OptionSetWidth(10),
 		OptionThrottle(65*time.Millisecond),
 		OptionShowCount(),
 		OptionShowIts(),
 		OptionSpinnerType(14),
 		OptionFullWidth(),
 	)
 	bar.RenderBlank()
 	return bar
 }
 // String returns the current rendered version of the progress bar.
 // It will never return an empty string while the progress bar is running.
 func (p *ProgressBar) String() string {
 	return p.state.rendered
 }
 // RenderBlank renders the current bar state, you can use this to render a 0% state
 func (p *ProgressBar) RenderBlank() error {
 	if p.config.invisible {
 		return nil
 	}
 	return p.render()
 }
 // Reset will reset the clock that is used
 // to calculate current time and the time left.
 func (p *ProgressBar) Reset() {
 	p.lock.Lock()
 	defer p.lock.Unlock()
 	p.state = getBasicState()
 }
 // Finish will fill the bar to full
 func (p *ProgressBar) Finish() error {
 	p.lock.Lock()
 	p.state.currentNum = p.config.max
 	p.lock.Unlock()
 	return p.Add(0)
 }
 // Add will add the specified amount to the progressbar
 func (p *ProgressBar) Add(num int) error {
 	return p.Add64(int64(num))
 }
 // Set wil set the bar to a current number
 func (p *ProgressBar) Set(num int) error {
 	return p.Set64(int64(num))
 }
 // Set64 wil set the bar to a current number
 func (p *ProgressBar) Set64(num int64) error {
 	p.lock.Lock()
 	toAdd := num - int64(p.state.currentBytes)
 	p.lock.Unlock()
 	return p.Add64(toAdd)
 }
 // Add64 will add the specified amount to the progressbar
 func (p *ProgressBar) Add64(num int64) error {
 	if p.config.invisible {
 		return nil
 	}
 	p.lock.Lock()
 	defer p.lock.Unlock()
 	if p.config.max == 0 {
 		return errors.New("max must be greater than 0")
 	}
 	if p.state.currentNum < p.config.max {
 		if p.config.ignoreLength {
 			p.state.currentNum = (p.state.currentNum + num) % p.config.max
 		} else {
 			p.state.currentNum += num
 		}
 	}
 	p.state.currentBytes += float64(num)
 	// reset the countdown timer every second to take rolling average
 	p.state.counterNumSinceLast += num
 	if time.Since(p.state.counterTime).Seconds() > 0.5 {
 		p.state.counterLastTenRates = append(p.state.counterLastTenRates, float64(p.state.counterNumSinceLast)/time.Since(p.state.counterTime).Seconds())
 		if len(p.state.counterLastTenRates) > 10 {
 			p.state.counterLastTenRates = p.state.counterLastTenRates[1:]
 		}
 		p.state.counterTime = time.Now()
 		p.state.counterNumSinceLast = 0
 	}
 	percent := float64(p.state.currentNum) / float64(p.config.max)
 	p.state.currentSaucerSize = int(percent * float64(p.config.width))
 	p.state.currentPercent = int(percent * 100)
 	updateBar := p.state.currentPercent != p.state.lastPercent && p.state.currentPercent > 0
 	p.state.lastPercent = p.state.currentPercent
 	if p.state.currentNum > p.config.max {
 		return errors.New("current number exceeds max")
 	}
 	// always update if show bytes/second or its/second
 	if updateBar || p.config.showIterationsPerSecond || p.config.showIterationsCount {
 		return p.render()
 	}
 	return nil
 }
 // Clear erases the progress bar from the current line
 func (p *ProgressBar) Clear() error {
 	return clearProgressBar(p.config, p.state)
 }
 // Describe will change the description shown before the progress, which
 // can be changed on the fly (as for a slow running process).
 func (p *ProgressBar) Describe(description string) {
 	p.config.description = description
 }
 // New64 returns a new ProgressBar
 // with the specified maximum
 func New64(max int64) *ProgressBar {
 	return NewOptions64(max)
 }
 // GetMax returns the max of a bar
 func (p *ProgressBar) GetMax() int {
 	return int(p.config.max)
 }
 // GetMax64 returns the current max
 func (p *ProgressBar) GetMax64() int64 {
 	return p.config.max
 }
 // ChangeMax takes in a int
 // and changes the max value
 // of the progress bar
 func (p *ProgressBar) ChangeMax(newMax int) {
 	p.ChangeMax64(int64(newMax))
 }
 // ChangeMax64 is basically
 // the same as ChangeMax,
 // but takes in a int64
 // to avoid casting
 func (p *ProgressBar) ChangeMax64(newMax int64) {
 	p.config.max = newMax
 	p.Add(0) // re-render
 }
 // IsFinished returns true if progreess bar is completed
 func (p *ProgressBar) IsFinished() bool {
 	return p.state.finished
 }
 // render renders the progress bar, updating the maximum
 // rendered line width. this function is not thread-safe,
 // so it must be called with an acquired lock.
 func (p *ProgressBar) render() error {
 	// make sure that the rendering is not happening too quickly
 	// but always show if the currentNum reaches the max
 	if time.Since(p.state.lastShown).Nanoseconds() < p.config.throttleDuration.Nanoseconds() &&
 		p.state.currentNum < p.config.max {
 		return nil
 	}
 	if !p.config.useANSICodes {
 		// first, clear the existing progress bar
 		err := clearProgressBar(p.config, p.state)
 		if err != nil {
 			return err
 		}
 	}
 	// check if the progress bar is finished
 	if !p.state.finished && p.state.currentNum >= p.config.max {
 		p.state.finished = true
 		if !p.config.clearOnFinish {
 			renderProgressBar(p.config, &p.state)
 		}
 		if p.config.onCompletion != nil {
 			p.config.onCompletion()
 		}
 	}
 	if p.state.finished {
 		// when using ANSI codes we don't pre-clean the current line
 		if p.config.useANSICodes {
 			err := clearProgressBar(p.config, p.state)
 			if err != nil {
 				return err
 			}
 		}
 		return nil
 	}
 	// then, re-render the current progress bar
 	w, err := renderProgressBar(p.config, &p.state)
 	if err != nil {
 		return err
 	}
 	if w > p.state.maxLineWidth {
 		p.state.maxLineWidth = w
 	}
 	p.state.lastShown = time.Now()
 	return nil
 }
 // State returns the current state
 func (p *ProgressBar) State() State {
 	p.lock.Lock()
 	defer p.lock.Unlock()
 	s := State{}
 	s.CurrentPercent = float64(p.state.currentNum) / float64(p.config.max)
 	s.CurrentBytes = p.state.currentBytes
 	s.SecondsSince = time.Since(p.state.startTime).Seconds()
 	if p.state.currentNum > 0 {
 		s.SecondsLeft = s.SecondsSince / float64(p.state.currentNum) * (float64(p.config.max) - float64(p.state.currentNum))
 	}
 	s.KBsPerSecond = float64(p.state.currentBytes) / 1024.0 / s.SecondsSince
 	return s
 }
 // regex matching ansi escape codes
 var ansiRegex = regexp.MustCompile(`\x1b\[[0-9;]*[a-zA-Z]`)
 func getStringWidth(c config, str string, colorize bool) int {
 	if c.colorCodes {
 		// convert any color codes in the progress bar into the respective ANSI codes
 		str = colorstring.Color(str)
 	}
 	// the width of the string, if printed to the console
 	// does not include the carriage return character
 	cleanString := strings.Replace(str, "\r", "", -1)
 	if c.colorCodes {
 		// the ANSI codes for the colors do not take up space in the console output,
 		// so they do not count towards the output string width
 		cleanString = ansiRegex.ReplaceAllString(cleanString, "")
 	}
 	// get the amount of runes in the string instead of the
 	// character count of the string, as some runes span multiple characters.
 	// see https://stackoverflow.com/a/12668840/2733724
 	stringWidth := runewidth.StringWidth(cleanString)
 	return stringWidth
 }
 func renderProgressBar(c config, s *state) (int, error) {
 	leftBrac := ""
 	rightBrac := ""
 	saucer := ""
 	bytesString := ""
 	str := ""
 	averageRate := average(s.counterLastTenRates)
 	if len(s.counterLastTenRates) == 0 || s.finished {
 		// if no average samples, or if finished,
 		// then average rate should be the total rate
 		averageRate = s.currentBytes / time.Since(s.startTime).Seconds()
 	}
 	// show iteration count in "current/total" iterations format
 	if c.showIterationsCount {
 		if bytesString == "" {
 			bytesString += "("
 		} else {
 			bytesString += ", "
 		}
 		if !c.ignoreLength {
 			if c.showBytes {
 				currentHumanize, currentSuffix := humanizeBytes(s.currentBytes)
 				if currentSuffix == c.maxHumanizedSuffix {
 					bytesString += fmt.Sprintf("%s/%s%s", currentHumanize, c.maxHumanized, c.maxHumanizedSuffix)
 				} else {
 					bytesString += fmt.Sprintf("%s%s/%s%s", currentHumanize, currentSuffix, c.maxHumanized, c.maxHumanizedSuffix)
 				}
 			} else {
 				bytesString += fmt.Sprintf("%.0f/%d", s.currentBytes, c.max)
 			}
 		} else {
 			if c.showBytes {
 				currentHumanize, currentSuffix := humanizeBytes(s.currentBytes)
 				bytesString += fmt.Sprintf("%s%s", currentHumanize, currentSuffix)
 			} else {
 				bytesString += fmt.Sprintf("%.0f/%s", s.currentBytes, "-")
 			}
 		}
 	}
 	// show rolling average rate in kB/sec or MB/sec
 	if c.showBytes {
 		if bytesString == "" {
 			bytesString += "("
 		} else {
 			bytesString += ", "
 		}
 		kbPerSecond := averageRate / 1024.0
 		if kbPerSecond > 1024.0 {
 			bytesString += fmt.Sprintf("%0.3f MB/s", kbPerSecond/1024.0)
 		} else if kbPerSecond > 0 {
 			bytesString += fmt.Sprintf("%0.3f kB/s", kbPerSecond)
 		}
 	}
 	// show iterations rate
 	if c.showIterationsPerSecond {
 		if bytesString == "" {
 			bytesString += "("
 		} else {
 			bytesString += ", "
 		}
 		if averageRate > 1 {
 			bytesString += fmt.Sprintf("%0.0f %s/s", averageRate, c.iterationString)
 		} else {
 			bytesString += fmt.Sprintf("%0.0f %s/min", 60*averageRate, c.iterationString)
 		}
 	}
 	if bytesString != "" {
 		bytesString += ")"
 	}
 	// show time prediction in "current/total" seconds format
 	if c.predictTime {
 		leftBrac = (time.Duration(time.Since(s.startTime).Seconds()) * time.Second).String()
 		rightBrac = (time.Duration((1/averageRate)*(float64(c.max)-float64(s.currentNum))) * time.Second).String()
 	}
 	if c.fullWidth && !c.ignoreLength {
 		width, _, err := terminal.GetSize(int(os.Stdout.Fd()))
 		if err != nil {
 			width, _, err = terminal.GetSize(int(os.Stderr.Fd()))
 			if err != nil {
 				width = 80
 			}
 		}
 		c.width = width - getStringWidth(c, c.description, true) - 14 - len(bytesString) - len(leftBrac) - len(rightBrac)
 		s.currentSaucerSize = int(float64(s.currentPercent) / 100.0 * float64(c.width))
 	}
 	if s.currentSaucerSize > 0 {
 		if c.ignoreLength {
 			saucer = strings.Repeat(c.theme.SaucerPadding, s.currentSaucerSize-1)
 		} else {
 			saucer = strings.Repeat(c.theme.Saucer, s.currentSaucerSize-1)
 		}
 		saucerHead := c.theme.SaucerHead
 		if saucerHead == "" || s.currentSaucerSize == c.width {
 			// use the saucer for the saucer head if it hasn't been set
 			// to preserve backwards compatibility
 			saucerHead = c.theme.Saucer
 		}
 		saucer += saucerHead
 	}
 	/*
 		Progress Bar format
 		Description % |------        |  (kb/s) (iteration count) (iteration rate) (predict time)
 	*/
 	repeatAmount := c.width - s.currentSaucerSize
 	if repeatAmount < 0 {
 		repeatAmount = 0
 	}
 	if c.ignoreLength {
 		str = fmt.Sprintf("\r%s %s %s ",
 			spinners[c.spinnerType][int(math.Round(math.Mod(float64(time.Since(s.startTime).Milliseconds()/100), float64(len(spinners[c.spinnerType])))))],
 			c.description,
 			bytesString,
 		)
 	} else if leftBrac == "" {
 		str = fmt.Sprintf("\r%s%4d%% %s%s%s%s %s ",
 			c.description,
 			s.currentPercent,
 			c.theme.BarStart,
 			saucer,
 			strings.Repeat(c.theme.SaucerPadding, repeatAmount),
 			c.theme.BarEnd,
 			bytesString,
 		)
 	} else {
 		if s.currentPercent == 100 {
 			str = fmt.Sprintf("\r%s%4d%% %s%s%s%s %s",
 				c.description,
 				s.currentPercent,
 				c.theme.BarStart,
 				saucer,
 				strings.Repeat(c.theme.SaucerPadding, repeatAmount),
 				c.theme.BarEnd,
 				bytesString,
 			)
 		} else {
 			str = fmt.Sprintf("\r%s%4d%% %s%s%s%s %s [%s:%s]",
 				c.description,
 				s.currentPercent,
 				c.theme.BarStart,
 				saucer,
 				strings.Repeat(c.theme.SaucerPadding, repeatAmount),
 				c.theme.BarEnd,
 				bytesString,
 				leftBrac,
 				rightBrac,
 			)
 		}
 	}
 	if c.colorCodes {
 		// convert any color codes in the progress bar into the respective ANSI codes
 		str = colorstring.Color(str)
 	}
 	s.rendered = str
 	return getStringWidth(c, str, false), writeString(c, str)
 }
 func clearProgressBar(c config, s state) error {
 	if c.useANSICodes {
 		// write the "clear current line" ANSI escape sequence
 		return writeString(c, "\033[2K\r")
 	}
 	// fill the empty content
 	// to overwrite the progress bar and jump
 	// back to the beginning of the line
 	str := fmt.Sprintf("\r%s\r", strings.Repeat(" ", s.maxLineWidth))
 	return writeString(c, str)
 	// the following does not show correctly if the previous line is longer than subsequent line
 	// return writeString(c, "\r")
 }
 func writeString(c config, str string) error {
 	if _, err := io.WriteString(c.writer, str); err != nil {
 		return err
 	}
 	if f, ok := c.writer.(*os.File); ok {
 		// ignore any errors in Sync(), as stdout
 		// can't be synced on some operating systems
 		// like Debian 9 (Stretch)
 		f.Sync()
 	}
 	return nil
 }
 // Reader is the progressbar io.Reader struct
 type Reader struct {
 	io.Reader
 	bar *ProgressBar
 }
 // NewReader return a new Reader with a given progress bar.
 func NewReader(r io.Reader, bar *ProgressBar) Reader {
 	return Reader{
 		Reader: r,
 		bar:    bar,
 	}
 }
 // Read will read the data and add the number of bytes to the progressbar
 func (r *Reader) Read(p []byte) (n int, err error) {
 	n, err = r.Reader.Read(p)
 	r.bar.Add(n)
 	return
 }
 // Close the reader when it implements io.Closer
 func (r *Reader) Close() (err error) {
 	if closer, ok := r.Reader.(io.Closer); ok {
 		return closer.Close()
 	}
 	r.bar.Finish()
 	return
 }
 // Write implement io.Writer
 func (p *ProgressBar) Write(b []byte) (n int, err error) {
 	n = len(b)
 	p.Add(n)
 	return
 }
 // Read implement io.Reader
 func (p *ProgressBar) Read(b []byte) (n int, err error) {
 	n = len(b)
 	p.Add(n)
 	return
 }
 func (p *ProgressBar) Close() (err error) {
 	p.Finish()
 	return
 }
 func average(xs []float64) float64 {
 	total := 0.0
 	for _, v := range xs {
 		total += v
 	}
 	return total / float64(len(xs))
 }
 func humanizeBytes(s float64) (string, string) {
 	sizes := []string{" B", " kB", " MB", " GB", " TB", " PB", " EB"}
 	base := 1024.0
 	if s < 10 {
 		return fmt.Sprintf("%2.0f", s), "B"
 	}
 	e := math.Floor(logn(float64(s), base))
 	suffix := sizes[int(e)]
 	val := math.Floor(float64(s)/math.Pow(base, e)*10+0.5) / 10
 	f := "%.0f"
 	if val < 10 {
 		f = "%.1f"
 	}
 	return fmt.Sprintf(f, val), suffix
 }
 func logn(n, b float64) float64 {
 	return math.Log(n) / math.Log(b)
 }
--- a/vendor/github.com/schollz/progressbar/v3/spinners.go
+++ b/vendor/github.com/schollz/progressbar/v3/spinners.go
@ -0,0 +1,80 @@
 package progressbar
 var spinners = map[int][]string{
 	0:  {"←", "↖", "↑", "↗", "→", "↘", "↓", "↙"},
 	1:  {"▁", "▃", "▄", "▅", "▆", "▇", "█", "▇", "▆", "▅", "▄", "▃", "▁"},
 	2:  {"▖", "▘", "▝", "▗"},
 	3:  {"┤", "┘", "┴", "└", "├", "┌", "┬", "┐"},
 	4:  {"◢", "◣", "◤", "◥"},
 	5:  {"◰", "◳", "◲", "◱"},
 	6:  {"◴", "◷", "◶", "◵"},
 	7:  {"◐", "◓", "◑", "◒"},
 	8:  {".", "o", "O", "@", "*"},
 	9:  {"|", "/", "-", "\\"},
 	10: {"◡◡", "⊙⊙", "◠◠"},
 	11: {"⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"},
 	12: {">))'>", " >))'>", "  >))'>", "   >))'>", "    >))'>", "   <'((<", "  <'((<", " <'((<"},
 	13: {"⠁", "⠂", "⠄", "⡀", "⢀", "⠠", "⠐", "⠈"},
 	14: {"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"},
 	15: {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"},
 	16: {"▉", "▊", "▋", "▌", "▍", "▎", "▏", "▎", "▍", "▌", "▋", "▊", "▉"},
 	17: {"■", "□", "▪", "▫"},
 	18: {"←", "↑", "→", "↓"},
 	19: {"╫", "╪"},
 	20: {"⇐", "⇖", "⇑", "⇗", "⇒", "⇘", "⇓", "⇙"},
 	21: {"⠁", "⠁", "⠉", "⠙", "⠚", "⠒", "⠂", "⠂", "⠒", "⠲", "⠴", "⠤", "⠄", "⠄", "⠤", "⠠", "⠠", "⠤", "⠦", "⠖", "⠒", "⠐", "⠐", "⠒", "⠓", "⠋", "⠉", "⠈", "⠈"},
 	22: {"⠈", "⠉", "⠋", "⠓", "⠒", "⠐", "⠐", "⠒", "⠖", "⠦", "⠤", "⠠", "⠠", "⠤", "⠦", "⠖", "⠒", "⠐", "⠐", "⠒", "⠓", "⠋", "⠉", "⠈"},
 	23: {"⠁", "⠉", "⠙", "⠚", "⠒", "⠂", "⠂", "⠒", "⠲", "⠴", "⠤", "⠄", "⠄", "⠤", "⠴", "⠲", "⠒", "⠂", "⠂", "⠒", "⠚", "⠙", "⠉", "⠁"},
 	24: {"⠋", "⠙", "⠚", "⠒", "⠂", "⠂", "⠒", "⠲", "⠴", "⠦", "⠖", "⠒", "⠐", "⠐", "⠒", "⠓", "⠋"},
 	25: {"ｦ", "ｧ", "ｨ", "ｩ", "ｪ", "ｫ", "ｬ", "ｭ", "ｮ", "ｯ", "ｱ", "ｲ", "ｳ", "ｴ", "ｵ", "ｶ", "ｷ", "ｸ", "ｹ", "ｺ", "ｻ", "ｼ", "ｽ", "ｾ", "ｿ", "ﾀ", "ﾁ", "ﾂ", "ﾃ", "ﾄ", "ﾅ", "ﾆ", "ﾇ", "ﾈ", "ﾉ", "ﾊ", "ﾋ", "ﾌ", "ﾍ", "ﾎ", "ﾏ", "ﾐ", "ﾑ", "ﾒ", "ﾓ", "ﾔ", "ﾕ", "ﾖ", "ﾗ", "ﾘ", "ﾙ", "ﾚ", "ﾛ", "ﾜ", "ﾝ"},
 	26: {".", "..", "..."},
 	27: {"▁", "▂", "▃", "▄", "▅", "▆", "▇", "█", "▉", "▊", "▋", "▌", "▍", "▎", "▏", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█", "▇", "▆", "▅", "▄", "▃", "▂", "▁"},
 	28: {".", "o", "O", "°", "O", "o", "."},
 	29: {"+", "x"},
 	30: {"v", "<", "^", ">"},
 	31: {">>--->", " >>--->", "  >>--->", "   >>--->", "    >>--->", "    <---<<", "   <---<<", "  <---<<", " <---<<", "<---<<"},
 	32: {"|", "||", "|||", "||||", "|||||", "|||||||", "||||||||", "|||||||", "||||||", "|||||", "||||", "|||", "||", "|"},
 	33: {"[          ]", "[=         ]", "[==        ]", "[===       ]", "[====      ]", "[=====     ]", "[======    ]", "[=======   ]", "[========  ]", "[========= ]", "[==========]"},
 	34: {"(*---------)", "(-*--------)", "(--*-------)", "(---*------)", "(----*-----)", "(-----*----)", "(------*---)", "(-------*--)", "(--------*-)", "(---------*)"},
 	35: {"█▒▒▒▒▒▒▒▒▒", "███▒▒▒▒▒▒▒", "█████▒▒▒▒▒", "███████▒▒▒", "██████████"},
 	36: {"[                    ]", "[=>                  ]", "[===>                ]", "[=====>              ]", "[======>             ]", "[========>           ]", "[==========>         ]", "[============>       ]", "[==============>     ]", "[================>   ]", "[==================> ]", "[===================>]"},
 	37: {"ဝ", "၀"},
 	38: {"▌", "▀", "▐▄"},
 	39: {"🌍", "🌎", "🌏"},
 	40: {"◜", "◝", "◞", "◟"},
 	41: {"⬒", "⬔", "⬓", "⬕"},
 	42: {"⬖", "⬘", "⬗", "⬙"},
 	43: {"[>>>          >]", "[]>>>>        []", "[]  >>>>      []", "[]    >>>>    []", "[]      >>>>  []", "[]        >>>>[]", "[>>          >>]"},
 	44: {"♠", "♣", "♥", "♦"},
 	45: {"➞", "➟", "➠", "➡", "➠", "➟"},
 	46: {"  |  ", ` \   `, "_    ", ` \   `, "  |  ", "   / ", "    _", "   / "},
 	47: {"  . . . .", ".   . . .", ". .   . .", ". . .   .", ". . . .  ", ". . . . ."},
 	48: {" |     ", "  /    ", "   _   ", `    \  `, "     | ", `    \  `, "   _   ", "  /    "},
 	49: {"⎺", "⎻", "⎼", "⎽", "⎼", "⎻"},
 	50: {"▹▹▹▹▹", "▸▹▹▹▹", "▹▸▹▹▹", "▹▹▸▹▹", "▹▹▹▸▹", "▹▹▹▹▸"},
 	51: {"[    ]", "[   =]", "[  ==]", "[ ===]", "[====]", "[=== ]", "[==  ]", "[=   ]"},
 	52: {"( ●    )", "(  ●   )", "(   ●  )", "(    ● )", "(     ●)", "(    ● )", "(   ●  )", "(  ●   )", "( ●    )"},
 	53: {"✶", "✸", "✹", "✺", "✹", "✷"},
 	54: {"▐|\\____________▌", "▐_|\\___________▌", "▐__|\\__________▌", "▐___|\\_________▌", "▐____|\\________▌", "▐_____|\\_______▌", "▐______|\\______▌", "▐_______|\\_____▌", "▐________|\\____▌", "▐_________|\\___▌", "▐__________|\\__▌", "▐___________|\\_▌", "▐____________|\\▌", "▐____________/|▌", "▐___________/|_▌", "▐__________/|__▌", "▐_________/|___▌", "▐________/|____▌", "▐_______/|_____▌", "▐______/|______▌", "▐_____/|_______▌", "▐____/|________▌", "▐___/|_________▌", "▐__/|__________▌", "▐_/|___________▌", "▐/|____________▌"},
 	55: {"▐⠂       ▌", "▐⠈       ▌", "▐ ⠂      ▌", "▐ ⠠      ▌", "▐  ⡀     ▌", "▐  ⠠     ▌", "▐   ⠂    ▌", "▐   ⠈    ▌", "▐    ⠂   ▌", "▐    ⠠   ▌", "▐     ⡀  ▌", "▐     ⠠  ▌", "▐      ⠂ ▌", "▐      ⠈ ▌", "▐       ⠂▌", "▐       ⠠▌", "▐       ⡀▌", "▐      ⠠ ▌", "▐      ⠂ ▌", "▐     ⠈  ▌", "▐     ⠂  ▌", "▐    ⠠   ▌", "▐    ⡀   ▌", "▐   ⠠    ▌", "▐   ⠂    ▌", "▐  ⠈     ▌", "▐  ⠂     ▌", "▐ ⠠      ▌", "▐ ⡀      ▌", "▐⠠       ▌"},
 	56: {"¿", "?"},
 	57: {"⢹", "⢺", "⢼", "⣸", "⣇", "⡧", "⡗", "⡏"},
 	58: {"⢄", "⢂", "⢁", "⡁", "⡈", "⡐", "⡠"},
 	59: {".  ", ".. ", "...", " ..", "  .", "   "},
 	60: {".", "o", "O", "°", "O", "o", "."},
 	61: {"▓", "▒", "░"},
 	62: {"▌", "▀", "▐", "▄"},
 	63: {"⊶", "⊷"},
 	64: {"▪", "▫"},
 	65: {"□", "■"},
 	66: {"▮", "▯"},
 	67: {"-", "=", "≡"},
 	68: {"d", "q", "p", "b"},
 	69: {"∙∙∙", "●∙∙", "∙●∙", "∙∙●", "∙∙∙"},
 	70: {"🌑 ", "🌒 ", "🌓 ", "🌔 ", "🌕 ", "🌖 ", "🌗 ", "🌘 "},
 	71: {"☗", "☖"},
 	72: {"⧇", "⧆"},
 	73: {"◉", "◎"},
 	74: {"㊂", "㊀", "㊁"},
 	75: {"⦾", "⦿"},
 }
--- a/vendor/golang.org/x/crypto/AUTHORS
+++ b/vendor/golang.org/x/crypto/AUTHORS
@ -0,0 +1,3 @@
 # This source code refers to The Go Authors for copyright purposes.
 # The master list of authors is in the main Go distribution,
 # visible at https://tip.golang.org/AUTHORS.
--- a/vendor/golang.org/x/crypto/CONTRIBUTORS
+++ b/vendor/golang.org/x/crypto/CONTRIBUTORS
@ -0,0 +1,3 @@
 # This source code was written by the Go contributors.
 # The master list of contributors is in the main Go distribution,
 # visible at https://tip.golang.org/CONTRIBUTORS.
--- a/vendor/golang.org/x/crypto/LICENSE
+++ b/vendor/golang.org/x/crypto/LICENSE
@ -0,0 +1,27 @@
 Copyright (c) 2009 The Go Authors. All rights reserved.
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:
   * Redistributions of source code must retain the above copyright
 notice, this list of conditions and the following disclaimer.
   * Redistributions in binary form must reproduce the above
 copyright notice, this list of conditions and the following disclaimer
 in the documentation and/or other materials provided with the
 distribution.
   * Neither the name of Google Inc. nor the names of its
 contributors may be used to endorse or promote products derived from
 this software without specific prior written permission.
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- a/vendor/golang.org/x/crypto/PATENTS
+++ b/vendor/golang.org/x/crypto/PATENTS
@ -0,0 +1,22 @@
 Additional IP Rights Grant (Patents)
 "This implementation" means the copyrightable works distributed by
 Google as part of the Go project.
 Google hereby grants to You a perpetual, worldwide, non-exclusive,
 no-charge, royalty-free, irrevocable (except as stated in this section)
 patent license to make, have made, use, offer to sell, sell, import,
 transfer and otherwise run, modify and propagate the contents of this
 implementation of Go, where such license applies only to those patent
 claims, both currently owned or controlled by Google and acquired in
 the future, licensable by Google that are necessarily infringed by this
 implementation of Go.  This grant does not include claims that would be
 infringed only as a consequence of further modification of this
 implementation.  If you or your agent or exclusive licensee institute or
 order or agree to the institution of patent litigation against any
 entity (including a cross-claim or counterclaim in a lawsuit) alleging
 that this implementation of Go or any code incorporated within this
 implementation of Go constitutes direct or contributory patent
 infringement, or inducement of patent infringement, then any patent
 rights granted to you under this License for this implementation of Go
 shall terminate as of the date such litigation is filed.
--- a/vendor/golang.org/x/crypto/ssh/terminal/terminal.go
+++ b/vendor/golang.org/x/crypto/ssh/terminal/terminal.go
@ -0,0 +1,76 @@
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // Package terminal provides support functions for dealing with terminals, as
 // commonly found on UNIX systems.
 //
 // Deprecated: this package moved to golang.org/x/term.
 package terminal
 import (
 	"io"
 	"golang.org/x/term"
 )
 // EscapeCodes contains escape sequences that can be written to the terminal in
 // order to achieve different styles of text.
 type EscapeCodes = term.EscapeCodes
 // Terminal contains the state for running a VT100 terminal that is capable of
 // reading lines of input.
 type Terminal = term.Terminal
 // NewTerminal runs a VT100 terminal on the given ReadWriter. If the ReadWriter is
 // a local terminal, that terminal must first have been put into raw mode.
 // prompt is a string that is written at the start of each input line (i.e.
 // "> ").
 func NewTerminal(c io.ReadWriter, prompt string) *Terminal {
 	return term.NewTerminal(c, prompt)
 }
 // ErrPasteIndicator may be returned from ReadLine as the error, in addition
 // to valid line data. It indicates that bracketed paste mode is enabled and
 // that the returned line consists only of pasted data. Programs may wish to
 // interpret pasted data more literally than typed data.
 var ErrPasteIndicator = term.ErrPasteIndicator
 // State contains the state of a terminal.
 type State = term.State
 // IsTerminal returns whether the given file descriptor is a terminal.
 func IsTerminal(fd int) bool {
 	return term.IsTerminal(fd)
 }
 // ReadPassword reads a line of input from a terminal without local echo.  This
 // is commonly used for inputting passwords and other sensitive data. The slice
 // returned does not include the \n.
 func ReadPassword(fd int) ([]byte, error) {
 	return term.ReadPassword(fd)
 }
 // MakeRaw puts the terminal connected to the given file descriptor into raw
 // mode and returns the previous state of the terminal so that it can be
 // restored.
 func MakeRaw(fd int) (*State, error) {
 	return term.MakeRaw(fd)
 }
 // Restore restores the terminal connected to the given file descriptor to a
 // previous state.
 func Restore(fd int, oldState *State) error {
 	return term.Restore(fd, oldState)
 }
 // GetState returns the current state of a terminal which may be useful to
 // restore the terminal after a signal.
 func GetState(fd int) (*State, error) {
 	return term.GetState(fd)
 }
 // GetSize returns the dimensions of the given terminal.
 func GetSize(fd int) (width, height int, err error) {
 	return term.GetSize(fd)
 }
--- a/vendor/golang.org/x/sys/AUTHORS
+++ b/vendor/golang.org/x/sys/AUTHORS
@ -0,0 +1,3 @@
 # This source code refers to The Go Authors for copyright purposes.
 # The master list of authors is in the main Go distribution,
 # visible at http://tip.golang.org/AUTHORS.
--- a/vendor/golang.org/x/sys/CONTRIBUTORS
+++ b/vendor/golang.org/x/sys/CONTRIBUTORS
@ -0,0 +1,3 @@
 # This source code was written by the Go contributors.
 # The master list of contributors is in the main Go distribution,
 # visible at http://tip.golang.org/CONTRIBUTORS.
--- a/vendor/golang.org/x/sys/LICENSE
+++ b/vendor/golang.org/x/sys/LICENSE
@ -0,0 +1,27 @@
 Copyright (c) 2009 The Go Authors. All rights reserved.
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:
   * Redistributions of source code must retain the above copyright
 notice, this list of conditions and the following disclaimer.
   * Redistributions in binary form must reproduce the above
 copyright notice, this list of conditions and the following disclaimer
 in the documentation and/or other materials provided with the
 distribution.
   * Neither the name of Google Inc. nor the names of its
 contributors may be used to endorse or promote products derived from
 this software without specific prior written permission.
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- a/vendor/golang.org/x/sys/PATENTS
+++ b/vendor/golang.org/x/sys/PATENTS
@ -0,0 +1,22 @@
 Additional IP Rights Grant (Patents)
 "This implementation" means the copyrightable works distributed by
 Google as part of the Go project.
 Google hereby grants to You a perpetual, worldwide, non-exclusive,
 no-charge, royalty-free, irrevocable (except as stated in this section)
 patent license to make, have made, use, offer to sell, sell, import,
 transfer and otherwise run, modify and propagate the contents of this
 implementation of Go, where such license applies only to those patent
 claims, both currently owned or controlled by Google and acquired in
 the future, licensable by Google that are necessarily infringed by this
 implementation of Go.  This grant does not include claims that would be
 infringed only as a consequence of further modification of this
 implementation.  If you or your agent or exclusive licensee institute or
 order or agree to the institution of patent litigation against any
 entity (including a cross-claim or counterclaim in a lawsuit) alleging
 that this implementation of Go or any code incorporated within this
 implementation of Go constitutes direct or contributory patent
 infringement, or inducement of patent infringement, then any patent
 rights granted to you under this License for this implementation of Go
 shall terminate as of the date such litigation is filed.
--- a/vendor/golang.org/x/sys/internal/unsafeheader/unsafeheader.go
+++ b/vendor/golang.org/x/sys/internal/unsafeheader/unsafeheader.go
@ -0,0 +1,30 @@
 // Copyright 2020 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // Package unsafeheader contains header declarations for the Go runtime's
 // slice and string implementations.
 //
 // This package allows x/sys to use types equivalent to
 // reflect.SliceHeader and reflect.StringHeader without introducing
 // a dependency on the (relatively heavy) "reflect" package.
 package unsafeheader
 import (
 	"unsafe"
 )
 // Slice is the runtime representation of a slice.
 // It cannot be used safely or portably and its representation may change in a later release.
 type Slice struct {
 	Data unsafe.Pointer
 	Len  int
 	Cap  int
 }
 // String is the runtime representation of a string.
 // It cannot be used safely or portably and its representation may change in a later release.
 type String struct {
 	Data unsafe.Pointer
 	Len  int
 }
--- a/vendor/golang.org/x/sys/plan9/asm.s
+++ b/vendor/golang.org/x/sys/plan9/asm.s
@ -0,0 +1,8 @@
 // Copyright 2014 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 #include "textflag.h"
 TEXT ·use(SB),NOSPLIT,$0
 	RET
--- a/vendor/golang.org/x/sys/plan9/asm_plan9_386.s
+++ b/vendor/golang.org/x/sys/plan9/asm_plan9_386.s
@ -0,0 +1,30 @@
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 #include "textflag.h"
 //
 // System call support for 386, Plan 9
 //
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT	·Syscall(SB),NOSPLIT,$0-32
 	JMP	syscall·Syscall(SB)
 TEXT	·Syscall6(SB),NOSPLIT,$0-44
 	JMP	syscall·Syscall6(SB)
 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
 	JMP	syscall·RawSyscall(SB)
 TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
 	JMP	syscall·RawSyscall6(SB)
 TEXT ·seek(SB),NOSPLIT,$0-36
 	JMP	syscall·seek(SB)
 TEXT ·exit(SB),NOSPLIT,$4-4
 	JMP	syscall·exit(SB)
--- a/vendor/golang.org/x/sys/plan9/asm_plan9_amd64.s
+++ b/vendor/golang.org/x/sys/plan9/asm_plan9_amd64.s
@ -0,0 +1,30 @@
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 #include "textflag.h"
 //
 // System call support for amd64, Plan 9
 //
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT	·Syscall(SB),NOSPLIT,$0-64
 	JMP	syscall·Syscall(SB)
 TEXT	·Syscall6(SB),NOSPLIT,$0-88
 	JMP	syscall·Syscall6(SB)
 TEXT ·RawSyscall(SB),NOSPLIT,$0-56
 	JMP	syscall·RawSyscall(SB)
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
 	JMP	syscall·RawSyscall6(SB)
 TEXT ·seek(SB),NOSPLIT,$0-56
 	JMP	syscall·seek(SB)
 TEXT ·exit(SB),NOSPLIT,$8-8
 	JMP	syscall·exit(SB)
--- a/vendor/golang.org/x/sys/plan9/asm_plan9_arm.s
+++ b/vendor/golang.org/x/sys/plan9/asm_plan9_arm.s
@ -0,0 +1,25 @@
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 #include "textflag.h"
 // System call support for plan9 on arm
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT ·Syscall(SB),NOSPLIT,$0-32
 	JMP	syscall·Syscall(SB)
 TEXT ·Syscall6(SB),NOSPLIT,$0-44
 	JMP	syscall·Syscall6(SB)
 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
 	JMP	syscall·RawSyscall(SB)
 TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
 	JMP	syscall·RawSyscall6(SB)
 TEXT ·seek(SB),NOSPLIT,$0-36
 	JMP	syscall·exit(SB)
--- a/vendor/golang.org/x/sys/plan9/const_plan9.go
+++ b/vendor/golang.org/x/sys/plan9/const_plan9.go
@ -0,0 +1,70 @@
 package plan9
 // Plan 9 Constants
 // Open modes
 const (
 	O_RDONLY  = 0
 	O_WRONLY  = 1
 	O_RDWR    = 2
 	O_TRUNC   = 16
 	O_CLOEXEC = 32
 	O_EXCL    = 0x1000
 )
 // Rfork flags
 const (
 	RFNAMEG  = 1 << 0
 	RFENVG   = 1 << 1
 	RFFDG    = 1 << 2
 	RFNOTEG  = 1 << 3
 	RFPROC   = 1 << 4
 	RFMEM    = 1 << 5
 	RFNOWAIT = 1 << 6
 	RFCNAMEG = 1 << 10
 	RFCENVG  = 1 << 11
 	RFCFDG   = 1 << 12
 	RFREND   = 1 << 13
 	RFNOMNT  = 1 << 14
 )
 // Qid.Type bits
 const (
 	QTDIR    = 0x80
 	QTAPPEND = 0x40
 	QTEXCL   = 0x20
 	QTMOUNT  = 0x10
 	QTAUTH   = 0x08
 	QTTMP    = 0x04
 	QTFILE   = 0x00
 )
 // Dir.Mode bits
 const (
 	DMDIR    = 0x80000000
 	DMAPPEND = 0x40000000
 	DMEXCL   = 0x20000000
 	DMMOUNT  = 0x10000000
 	DMAUTH   = 0x08000000
 	DMTMP    = 0x04000000
 	DMREAD   = 0x4
 	DMWRITE  = 0x2
 	DMEXEC   = 0x1
 )
 const (
 	STATMAX    = 65535
 	ERRMAX     = 128
 	STATFIXLEN = 49
 )
 // Mount and bind flags
 const (
 	MREPL   = 0x0000
 	MBEFORE = 0x0001
 	MAFTER  = 0x0002
 	MORDER  = 0x0003
 	MCREATE = 0x0004
 	MCACHE  = 0x0010
 	MMASK   = 0x0017
 )
--- a/vendor/golang.org/x/sys/plan9/dir_plan9.go
+++ b/vendor/golang.org/x/sys/plan9/dir_plan9.go
@ -0,0 +1,212 @@
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // Plan 9 directory marshalling. See intro(5).
 package plan9
 import "errors"
 var (
 	ErrShortStat = errors.New("stat buffer too short")
 	ErrBadStat   = errors.New("malformed stat buffer")
 	ErrBadName   = errors.New("bad character in file name")
 )
 // A Qid represents a 9P server's unique identification for a file.
 type Qid struct {
 	Path uint64 // the file server's unique identification for the file
 	Vers uint32 // version number for given Path
 	Type uint8  // the type of the file (plan9.QTDIR for example)
 }
 // A Dir contains the metadata for a file.
 type Dir struct {
 	// system-modified data
 	Type uint16 // server type
 	Dev  uint32 // server subtype
 	// file data
 	Qid    Qid    // unique id from server
 	Mode   uint32 // permissions
 	Atime  uint32 // last read time
 	Mtime  uint32 // last write time
 	Length int64  // file length
 	Name   string // last element of path
 	Uid    string // owner name
 	Gid    string // group name
 	Muid   string // last modifier name
 }
 var nullDir = Dir{
 	Type: ^uint16(0),
 	Dev:  ^uint32(0),
 	Qid: Qid{
 		Path: ^uint64(0),
 		Vers: ^uint32(0),
 		Type: ^uint8(0),
 	},
 	Mode:   ^uint32(0),
 	Atime:  ^uint32(0),
 	Mtime:  ^uint32(0),
 	Length: ^int64(0),
 }
 // Null assigns special "don't touch" values to members of d to
 // avoid modifying them during plan9.Wstat.
 func (d *Dir) Null() { *d = nullDir }
 // Marshal encodes a 9P stat message corresponding to d into b
 //
 // If there isn't enough space in b for a stat message, ErrShortStat is returned.
 func (d *Dir) Marshal(b []byte) (n int, err error) {
 	n = STATFIXLEN + len(d.Name) + len(d.Uid) + len(d.Gid) + len(d.Muid)
 	if n > len(b) {
 		return n, ErrShortStat
 	}
 	for _, c := range d.Name {
 		if c == '/' {
 			return n, ErrBadName
 		}
 	}
 	b = pbit16(b, uint16(n)-2)
 	b = pbit16(b, d.Type)
 	b = pbit32(b, d.Dev)
 	b = pbit8(b, d.Qid.Type)
 	b = pbit32(b, d.Qid.Vers)
 	b = pbit64(b, d.Qid.Path)
 	b = pbit32(b, d.Mode)
 	b = pbit32(b, d.Atime)
 	b = pbit32(b, d.Mtime)
 	b = pbit64(b, uint64(d.Length))
 	b = pstring(b, d.Name)
 	b = pstring(b, d.Uid)
 	b = pstring(b, d.Gid)
 	b = pstring(b, d.Muid)
 	return n, nil
 }
 // UnmarshalDir decodes a single 9P stat message from b and returns the resulting Dir.
 //
 // If b is too small to hold a valid stat message, ErrShortStat is returned.
 //
 // If the stat message itself is invalid, ErrBadStat is returned.
 func UnmarshalDir(b []byte) (*Dir, error) {
 	if len(b) < STATFIXLEN {
 		return nil, ErrShortStat
 	}
 	size, buf := gbit16(b)
 	if len(b) != int(size)+2 {
 		return nil, ErrBadStat
 	}
 	b = buf
 	var d Dir
 	d.Type, b = gbit16(b)
 	d.Dev, b = gbit32(b)
 	d.Qid.Type, b = gbit8(b)
 	d.Qid.Vers, b = gbit32(b)
 	d.Qid.Path, b = gbit64(b)
 	d.Mode, b = gbit32(b)
 	d.Atime, b = gbit32(b)
 	d.Mtime, b = gbit32(b)
 	n, b := gbit64(b)
 	d.Length = int64(n)
 	var ok bool
 	if d.Name, b, ok = gstring(b); !ok {
 		return nil, ErrBadStat
 	}
 	if d.Uid, b, ok = gstring(b); !ok {
 		return nil, ErrBadStat
 	}
 	if d.Gid, b, ok = gstring(b); !ok {
 		return nil, ErrBadStat
 	}
 	if d.Muid, b, ok = gstring(b); !ok {
 		return nil, ErrBadStat
 	}
 	return &d, nil
 }
 // pbit8 copies the 8-bit number v to b and returns the remaining slice of b.
 func pbit8(b []byte, v uint8) []byte {
 	b[0] = byte(v)
 	return b[1:]
 }
 // pbit16 copies the 16-bit number v to b in little-endian order and returns the remaining slice of b.
 func pbit16(b []byte, v uint16) []byte {
 	b[0] = byte(v)
 	b[1] = byte(v >> 8)
 	return b[2:]
 }
 // pbit32 copies the 32-bit number v to b in little-endian order and returns the remaining slice of b.
 func pbit32(b []byte, v uint32) []byte {
 	b[0] = byte(v)
 	b[1] = byte(v >> 8)
 	b[2] = byte(v >> 16)
 	b[3] = byte(v >> 24)
 	return b[4:]
 }
 // pbit64 copies the 64-bit number v to b in little-endian order and returns the remaining slice of b.
 func pbit64(b []byte, v uint64) []byte {
 	b[0] = byte(v)
 	b[1] = byte(v >> 8)
 	b[2] = byte(v >> 16)
 	b[3] = byte(v >> 24)
 	b[4] = byte(v >> 32)
 	b[5] = byte(v >> 40)
 	b[6] = byte(v >> 48)
 	b[7] = byte(v >> 56)
 	return b[8:]
 }
 // pstring copies the string s to b, prepending it with a 16-bit length in little-endian order, and
 // returning the remaining slice of b..
 func pstring(b []byte, s string) []byte {
 	b = pbit16(b, uint16(len(s)))
 	n := copy(b, s)
 	return b[n:]
 }
 // gbit8 reads an 8-bit number from b and returns it with the remaining slice of b.
 func gbit8(b []byte) (uint8, []byte) {
 	return uint8(b[0]), b[1:]
 }
 // gbit16 reads a 16-bit number in little-endian order from b and returns it with the remaining slice of b.
 func gbit16(b []byte) (uint16, []byte) {
 	return uint16(b[0]) | uint16(b[1])<<8, b[2:]
 }
 // gbit32 reads a 32-bit number in little-endian order from b and returns it with the remaining slice of b.
 func gbit32(b []byte) (uint32, []byte) {
 	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24, b[4:]
 }
 // gbit64 reads a 64-bit number in little-endian order from b and returns it with the remaining slice of b.
 func gbit64(b []byte) (uint64, []byte) {
 	lo := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
 	hi := uint32(b[4]) | uint32(b[5])<<8 | uint32(b[6])<<16 | uint32(b[7])<<24
 	return uint64(lo) | uint64(hi)<<32, b[8:]
 }
 // gstring reads a string from b, prefixed with a 16-bit length in little-endian order.
 // It returns the string with the remaining slice of b and a boolean. If the length is
 // greater than the number of bytes in b, the boolean will be false.
 func gstring(b []byte) (string, []byte, bool) {
 	n, b := gbit16(b)
 	if int(n) > len(b) {
 		return "", b, false
 	}
 	return string(b[:n]), b[n:], true
 }
--- a/vendor/golang.org/x/sys/plan9/env_plan9.go
+++ b/vendor/golang.org/x/sys/plan9/env_plan9.go
@ -0,0 +1,31 @@
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // Plan 9 environment variables.
 package plan9
 import (
 	"syscall"
 )
 func Getenv(key string) (value string, found bool) {
 	return syscall.Getenv(key)
 }
 func Setenv(key, value string) error {
 	return syscall.Setenv(key, value)
 }
 func Clearenv() {
 	syscall.Clearenv()
 }
 func Environ() []string {
 	return syscall.Environ()
 }
 func Unsetenv(key string) error {
 	return syscall.Unsetenv(key)
 }
--- a/vendor/golang.org/x/sys/plan9/errors_plan9.go
+++ b/vendor/golang.org/x/sys/plan9/errors_plan9.go
@ -0,0 +1,50 @@
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 package plan9
 import "syscall"
 // Constants
 const (
 	// Invented values to support what package os expects.
 	O_CREAT    = 0x02000
 	O_APPEND   = 0x00400
 	O_NOCTTY   = 0x00000
 	O_NONBLOCK = 0x00000
 	O_SYNC     = 0x00000
 	O_ASYNC    = 0x00000
 	S_IFMT   = 0x1f000
 	S_IFIFO  = 0x1000
 	S_IFCHR  = 0x2000
 	S_IFDIR  = 0x4000
 	S_IFBLK  = 0x6000
 	S_IFREG  = 0x8000
 	S_IFLNK  = 0xa000
 	S_IFSOCK = 0xc000
 )
 // Errors
 var (
 	EINVAL       = syscall.NewError("bad arg in system call")
 	ENOTDIR      = syscall.NewError("not a directory")
 	EISDIR       = syscall.NewError("file is a directory")
 	ENOENT       = syscall.NewError("file does not exist")
 	EEXIST       = syscall.NewError("file already exists")
 	EMFILE       = syscall.NewError("no free file descriptors")
 	EIO          = syscall.NewError("i/o error")
 	ENAMETOOLONG = syscall.NewError("file name too long")
 	EINTR        = syscall.NewError("interrupted")
 	EPERM        = syscall.NewError("permission denied")
 	EBUSY        = syscall.NewError("no free devices")
 	ETIMEDOUT    = syscall.NewError("connection timed out")
 	EPLAN9       = syscall.NewError("not supported by plan 9")
 	// The following errors do not correspond to any
 	// Plan 9 system messages. Invented to support
 	// what package os and others expect.
 	EACCES       = syscall.NewError("access permission denied")
 	EAFNOSUPPORT = syscall.NewError("address family not supported by protocol")
 )
--- a/vendor/golang.org/x/sys/plan9/mkall.sh
+++ b/vendor/golang.org/x/sys/plan9/mkall.sh
@ -0,0 +1,150 @@
 #!/usr/bin/env bash
 # Copyright 2009 The Go Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style
 # license that can be found in the LICENSE file.
 # The plan9 package provides access to the raw system call
 # interface of the underlying operating system.  Porting Go to
 # a new architecture/operating system combination requires
 # some manual effort, though there are tools that automate
 # much of the process.  The auto-generated files have names
 # beginning with z.
 #
 # This script runs or (given -n) prints suggested commands to generate z files
 # for the current system.  Running those commands is not automatic.
 # This script is documentation more than anything else.
 #
 # * asm_${GOOS}_${GOARCH}.s
 #
 # This hand-written assembly file implements system call dispatch.
 # There are three entry points:
 #
 # 	func Syscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr);
 # 	func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr);
 # 	func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr);
 #
 # The first and second are the standard ones; they differ only in
 # how many arguments can be passed to the kernel.
 # The third is for low-level use by the ForkExec wrapper;
 # unlike the first two, it does not call into the scheduler to
 # let it know that a system call is running.
 #
 # * syscall_${GOOS}.go
 #
 # This hand-written Go file implements system calls that need
 # special handling and lists "//sys" comments giving prototypes
 # for ones that can be auto-generated.  Mksyscall reads those
 # comments to generate the stubs.
 #
 # * syscall_${GOOS}_${GOARCH}.go
 #
 # Same as syscall_${GOOS}.go except that it contains code specific
 # to ${GOOS} on one particular architecture.
 #
 # * types_${GOOS}.c
 #
 # This hand-written C file includes standard C headers and then
 # creates typedef or enum names beginning with a dollar sign
 # (use of $ in variable names is a gcc extension).  The hardest
 # part about preparing this file is figuring out which headers to
 # include and which symbols need to be #defined to get the
 # actual data structures that pass through to the kernel system calls.
 # Some C libraries present alternate versions for binary compatibility
 # and translate them on the way in and out of system calls, but
 # there is almost always a #define that can get the real ones.
 # See types_darwin.c and types_linux.c for examples.
 #
 # * zerror_${GOOS}_${GOARCH}.go
 #
 # This machine-generated file defines the system's error numbers,
 # error strings, and signal numbers.  The generator is "mkerrors.sh".
 # Usually no arguments are needed, but mkerrors.sh will pass its
 # arguments on to godefs.
 #
 # * zsyscall_${GOOS}_${GOARCH}.go
 #
 # Generated by mksyscall.pl; see syscall_${GOOS}.go above.
 #
 # * zsysnum_${GOOS}_${GOARCH}.go
 #
 # Generated by mksysnum_${GOOS}.
 #
 # * ztypes_${GOOS}_${GOARCH}.go
 #
 # Generated by godefs; see types_${GOOS}.c above.
 GOOSARCH="${GOOS}_${GOARCH}"
 # defaults
 mksyscall="go run mksyscall.go"
 mkerrors="./mkerrors.sh"
 zerrors="zerrors_$GOOSARCH.go"
 mksysctl=""
 zsysctl="zsysctl_$GOOSARCH.go"
 mksysnum=
 mktypes=
 run="sh"
 case "$1" in
 -syscalls)
 	for i in zsyscall*go
 	do
 		sed 1q $i | sed 's;^// ;;' | sh > _$i && gofmt < _$i > $i
 		rm _$i
 	done
 	exit 0
 	;;
 -n)
 	run="cat"
 	shift
 esac
 case "$#" in
 0)
 	;;
 *)
 	echo 'usage: mkall.sh [-n]' 1>&2
 	exit 2
 esac
 case "$GOOSARCH" in
 _* | *_ | _)
 	echo 'undefined $GOOS_$GOARCH:' "$GOOSARCH" 1>&2
 	exit 1
 	;;
 plan9_386)
 	mkerrors=
 	mksyscall="go run mksyscall.go -l32 -plan9 -tags plan9,386"
 	mksysnum="./mksysnum_plan9.sh /n/sources/plan9/sys/src/libc/9syscall/sys.h"
 	mktypes="XXX"
 	;;
 plan9_amd64)
 	mkerrors=
 	mksyscall="go run mksyscall.go -l32 -plan9 -tags plan9,amd64"
 	mksysnum="./mksysnum_plan9.sh /n/sources/plan9/sys/src/libc/9syscall/sys.h"
 	mktypes="XXX"
 	;;
 plan9_arm)
 	mkerrors=
 	mksyscall="go run mksyscall.go -l32 -plan9 -tags plan9,arm"
 	mksysnum="./mksysnum_plan9.sh /n/sources/plan9/sys/src/libc/9syscall/sys.h"
 	mktypes="XXX"
 	;;
 *)
 	echo 'unrecognized $GOOS_$GOARCH: ' "$GOOSARCH" 1>&2
 	exit 1
 	;;
 esac
 (
 	if [ -n "$mkerrors" ]; then echo "$mkerrors |gofmt >$zerrors"; fi
 	case "$GOOS" in
 	plan9)
 		syscall_goos="syscall_$GOOS.go"
 		if [ -n "$mksyscall" ]; then echo "$mksyscall $syscall_goos |gofmt >zsyscall_$GOOSARCH.go"; fi
 		;;
 	esac
 	if [ -n "$mksysctl" ]; then echo "$mksysctl |gofmt >$zsysctl"; fi
 	if [ -n "$mksysnum" ]; then echo "$mksysnum |gofmt >zsysnum_$GOOSARCH.go"; fi
 	if [ -n "$mktypes" ]; then echo "$mktypes types_$GOOS.go |gofmt >ztypes_$GOOSARCH.go"; fi
 ) | $run
--- a/vendor/golang.org/x/sys/plan9/mkerrors.sh
+++ b/vendor/golang.org/x/sys/plan9/mkerrors.sh
@ -0,0 +1,246 @@
 #!/usr/bin/env bash
 # Copyright 2009 The Go Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style
 # license that can be found in the LICENSE file.
 # Generate Go code listing errors and other #defined constant
 # values (ENAMETOOLONG etc.), by asking the preprocessor
 # about the definitions.
 unset LANG
 export LC_ALL=C
 export LC_CTYPE=C
 CC=${CC:-gcc}
 uname=$(uname)
 includes='
 #include <sys/types.h>
 #include <sys/file.h>
 #include <fcntl.h>
 #include <dirent.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netinet/ip.h>
 #include <netinet/ip6.h>
 #include <netinet/tcp.h>
 #include <errno.h>
 #include <sys/signal.h>
 #include <signal.h>
 #include <sys/resource.h>
 '
 ccflags="$@"
 # Write go tool cgo -godefs input.
 (
 	echo package plan9
 	echo
 	echo '/*'
 	indirect="includes_$(uname)"
 	echo "${!indirect} $includes"
 	echo '*/'
 	echo 'import "C"'
 	echo
 	echo 'const ('
 	# The gcc command line prints all the #defines
 	# it encounters while processing the input
 	echo "${!indirect} $includes" | $CC -x c - -E -dM $ccflags |
 	awk '
 		$1 != "#define" || $2 ~ /\(/ || $3 == "" {next}
 		$2 ~ /^E([ABCD]X|[BIS]P|[SD]I|S|FL)$/ {next}  # 386 registers
 		$2 ~ /^(SIGEV_|SIGSTKSZ|SIGRT(MIN|MAX))/ {next}
 		$2 ~ /^(SCM_SRCRT)$/ {next}
 		$2 ~ /^(MAP_FAILED)$/ {next}
 		$2 !~ /^ETH_/ &&
 		$2 !~ /^EPROC_/ &&
 		$2 !~ /^EQUIV_/ &&
 		$2 !~ /^EXPR_/ &&
 		$2 ~ /^E[A-Z0-9_]+$/ ||
 		$2 ~ /^B[0-9_]+$/ ||
 		$2 ~ /^V[A-Z0-9]+$/ ||
 		$2 ~ /^CS[A-Z0-9]/ ||
 		$2 ~ /^I(SIG|CANON|CRNL|EXTEN|MAXBEL|STRIP|UTF8)$/ ||
 		$2 ~ /^IGN/ ||
 		$2 ~ /^IX(ON|ANY|OFF)$/ ||
 		$2 ~ /^IN(LCR|PCK)$/ ||
 		$2 ~ /(^FLU?SH)|(FLU?SH$)/ ||
 		$2 ~ /^C(LOCAL|READ)$/ ||
 		$2 == "BRKINT" ||
 		$2 == "HUPCL" ||
 		$2 == "PENDIN" ||
 		$2 == "TOSTOP" ||
 		$2 ~ /^PAR/ ||
 		$2 ~ /^SIG[^_]/ ||
 		$2 ~ /^O[CNPFP][A-Z]+[^_][A-Z]+$/ ||
 		$2 ~ /^IN_/ ||
 		$2 ~ /^LOCK_(SH|EX|NB|UN)$/ ||
 		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|EVFILT|NOTE|EV|SHUT|PROT|MAP|PACKET|MSG|SCM|MCL|DT|MADV|PR)_/ ||
 		$2 == "ICMPV6_FILTER" ||
 		$2 == "SOMAXCONN" ||
 		$2 == "NAME_MAX" ||
 		$2 == "IFNAMSIZ" ||
 		$2 ~ /^CTL_(MAXNAME|NET|QUERY)$/ ||
 		$2 ~ /^SYSCTL_VERS/ ||
 		$2 ~ /^(MS|MNT)_/ ||
 		$2 ~ /^TUN(SET|GET|ATTACH|DETACH)/ ||
 		$2 ~ /^(O|F|FD|NAME|S|PTRACE|PT)_/ ||
 		$2 ~ /^LINUX_REBOOT_CMD_/ ||
 		$2 ~ /^LINUX_REBOOT_MAGIC[12]$/ ||
 		$2 !~ "NLA_TYPE_MASK" &&
 		$2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P)_/ ||
 		$2 ~ /^SIOC/ ||
 		$2 ~ /^TIOC/ ||
 		$2 !~ "RTF_BITS" &&
 		$2 ~ /^(IFF|IFT|NET_RT|RTM|RTF|RTV|RTA|RTAX)_/ ||
 		$2 ~ /^BIOC/ ||
 		$2 ~ /^RUSAGE_(SELF|CHILDREN|THREAD)/ ||
 		$2 ~ /^RLIMIT_(AS|CORE|CPU|DATA|FSIZE|NOFILE|STACK)|RLIM_INFINITY/ ||
 		$2 ~ /^PRIO_(PROCESS|PGRP|USER)/ ||
 		$2 ~ /^CLONE_[A-Z_]+/ ||
 		$2 !~ /^(BPF_TIMEVAL)$/ &&
 		$2 ~ /^(BPF|DLT)_/ ||
 		$2 !~ "WMESGLEN" &&
 		$2 ~ /^W[A-Z0-9]+$/ {printf("\t%s = C.%s\n", $2, $2)}
 		$2 ~ /^__WCOREFLAG$/ {next}
 		$2 ~ /^__W[A-Z0-9]+$/ {printf("\t%s = C.%s\n", substr($2,3), $2)}
 		{next}
 	' | sort
 	echo ')'
 ) >_const.go
 # Pull out the error names for later.
 errors=$(
 	echo '#include <errno.h>' | $CC -x c - -E -dM $ccflags |
 	awk '$1=="#define" && $2 ~ /^E[A-Z0-9_]+$/ { print $2 }' |
 	sort
 )
 # Pull out the signal names for later.
 signals=$(
 	echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
 	awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print $2 }' |
 	egrep -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT)' |
 	sort
 )
 # Again, writing regexps to a file.
 echo '#include <errno.h>' | $CC -x c - -E -dM $ccflags |
 	awk '$1=="#define" && $2 ~ /^E[A-Z0-9_]+$/ { print "^\t" $2 "[ \t]*=" }' |
 	sort >_error.grep
 echo '#include <signal.h>' | $CC -x c - -E -dM $ccflags |
 	awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print "^\t" $2 "[ \t]*=" }' |
 	egrep -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT)' |
 	sort >_signal.grep
 echo '// mkerrors.sh' "$@"
 echo '// Code generated by the command above; DO NOT EDIT.'
 echo
 go tool cgo -godefs -- "$@" _const.go >_error.out
 cat _error.out | grep -vf _error.grep | grep -vf _signal.grep
 echo
 echo '// Errors'
 echo 'const ('
 cat _error.out | grep -f _error.grep | sed 's/=\(.*\)/= Errno(\1)/'
 echo ')'
 echo
 echo '// Signals'
 echo 'const ('
 cat _error.out | grep -f _signal.grep | sed 's/=\(.*\)/= Signal(\1)/'
 echo ')'
 # Run C program to print error and syscall strings.
 (
 	echo -E "
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <ctype.h>
 #include <string.h>
 #include <signal.h>
 #define nelem(x) (sizeof(x)/sizeof((x)[0]))
 enum { A = 'A', Z = 'Z', a = 'a', z = 'z' }; // avoid need for single quotes below
 int errors[] = {
 "
 	for i in $errors
 	do
 		echo -E '	'$i,
 	done
 	echo -E "
 };
 int signals[] = {
 "
 	for i in $signals
 	do
 		echo -E '	'$i,
 	done
 	# Use -E because on some systems bash builtin interprets \n itself.
 	echo -E '
 };
 static int
 intcmp(const void *a, const void *b)
 {
 	return *(int*)a - *(int*)b;
 }
 int
 main(void)
 {
 	int i, j, e;
 	char buf[1024], *p;
 	printf("\n\n// Error table\n");
 	printf("var errors = [...]string {\n");
 	qsort(errors, nelem(errors), sizeof errors[0], intcmp);
 	for(i=0; i<nelem(errors); i++) {
 		e = errors[i];
 		if(i > 0 && errors[i-1] == e)
 			continue;
 		strcpy(buf, strerror(e));
 		// lowercase first letter: Bad -> bad, but STREAM -> STREAM.
 		if(A <= buf[0] && buf[0] <= Z && a <= buf[1] && buf[1] <= z)
 			buf[0] += a - A;
 		printf("\t%d: \"%s\",\n", e, buf);
 	}
 	printf("}\n\n");
 	printf("\n\n// Signal table\n");
 	printf("var signals = [...]string {\n");
 	qsort(signals, nelem(signals), sizeof signals[0], intcmp);
 	for(i=0; i<nelem(signals); i++) {
 		e = signals[i];
 		if(i > 0 && signals[i-1] == e)
 			continue;
 		strcpy(buf, strsignal(e));
 		// lowercase first letter: Bad -> bad, but STREAM -> STREAM.
 		if(A <= buf[0] && buf[0] <= Z && a <= buf[1] && buf[1] <= z)
 			buf[0] += a - A;
 		// cut trailing : number.
 		p = strrchr(buf, ":"[0]);
 		if(p)
 			*p = '\0';
 		printf("\t%d: \"%s\",\n", e, buf);
 	}
 	printf("}\n\n");
 	return 0;
 }
 '
 ) >_errors.c
 $CC $ccflags -o _errors _errors.c && $GORUN ./_errors && rm -f _errors.c _errors _const.go _error.grep _signal.grep _error.out
--- a/vendor/golang.org/x/sys/plan9/mksysnum_plan9.sh
+++ b/vendor/golang.org/x/sys/plan9/mksysnum_plan9.sh
@ -0,0 +1,23 @@
 #!/bin/sh
 # Copyright 2009 The Go Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style
 # license that can be found in the LICENSE file.
 COMMAND="mksysnum_plan9.sh $@"
 cat <<EOF
 // $COMMAND
 // MACHINE GENERATED BY THE ABOVE COMMAND; DO NOT EDIT
 package plan9
 const(
 EOF
 SP='[ 	]' # space or tab
 sed "s/^#define${SP}\\([A-Z0-9_][A-Z0-9_]*\\)${SP}${SP}*\\([0-9][0-9]*\\)/SYS_\\1=\\2/g" \
 	< $1 | grep -v SYS__
 cat <<EOF
 )
 EOF
--- a/vendor/golang.org/x/sys/plan9/pwd_go15_plan9.go
+++ b/vendor/golang.org/x/sys/plan9/pwd_go15_plan9.go
@ -0,0 +1,21 @@
 // Copyright 2015 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // +build go1.5
 package plan9
 import "syscall"
 func fixwd() {
 	syscall.Fixwd()
 }
 func Getwd() (wd string, err error) {
 	return syscall.Getwd()
 }
 func Chdir(path string) error {
 	return syscall.Chdir(path)
 }
--- a/vendor/golang.org/x/sys/plan9/pwd_plan9.go
+++ b/vendor/golang.org/x/sys/plan9/pwd_plan9.go
@ -0,0 +1,23 @@
 // Copyright 2015 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // +build !go1.5
 package plan9
 func fixwd() {
 }
 func Getwd() (wd string, err error) {
 	fd, err := open(".", O_RDONLY)
 	if err != nil {
 		return "", err
 	}
 	defer Close(fd)
 	return Fd2path(fd)
 }
 func Chdir(path string) error {
 	return chdir(path)
 }
--- a/vendor/golang.org/x/sys/plan9/race.go
+++ b/vendor/golang.org/x/sys/plan9/race.go
@ -0,0 +1,30 @@
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // +build plan9,race
 package plan9
 import (
 	"runtime"
 	"unsafe"
 )
 const raceenabled = true
 func raceAcquire(addr unsafe.Pointer) {
 	runtime.RaceAcquire(addr)
 }
 func raceReleaseMerge(addr unsafe.Pointer) {
 	runtime.RaceReleaseMerge(addr)
 }
 func raceReadRange(addr unsafe.Pointer, len int) {
 	runtime.RaceReadRange(addr, len)
 }
 func raceWriteRange(addr unsafe.Pointer, len int) {
 	runtime.RaceWriteRange(addr, len)
 }
--- a/vendor/golang.org/x/sys/plan9/race0.go
+++ b/vendor/golang.org/x/sys/plan9/race0.go
@ -0,0 +1,25 @@
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // +build plan9,!race
 package plan9
 import (
 	"unsafe"
 )
 const raceenabled = false
 func raceAcquire(addr unsafe.Pointer) {
 }
 func raceReleaseMerge(addr unsafe.Pointer) {
 }
 func raceReadRange(addr unsafe.Pointer, len int) {
 }
 func raceWriteRange(addr unsafe.Pointer, len int) {
 }
--- a/vendor/golang.org/x/sys/plan9/str.go
+++ b/vendor/golang.org/x/sys/plan9/str.go
@ -0,0 +1,22 @@
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // +build plan9
 package plan9
 func itoa(val int) string { // do it here rather than with fmt to avoid dependency
 	if val < 0 {
 		return "-" + itoa(-val)
 	}
 	var buf [32]byte // big enough for int64
 	i := len(buf) - 1
 	for val >= 10 {
 		buf[i] = byte(val%10 + '0')
 		i--
 		val /= 10
 	}
 	buf[i] = byte(val + '0')
 	return string(buf[i:])
 }
--- a/vendor/golang.org/x/sys/plan9/syscall.go
+++ b/vendor/golang.org/x/sys/plan9/syscall.go
@ -0,0 +1,116 @@
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // +build plan9
 // Package plan9 contains an interface to the low-level operating system
 // primitives. OS details vary depending on the underlying system, and
 // by default, godoc will display the OS-specific documentation for the current
 // system. If you want godoc to display documentation for another
 // system, set $GOOS and $GOARCH to the desired system. For example, if
 // you want to view documentation for freebsd/arm on linux/amd64, set $GOOS
 // to freebsd and $GOARCH to arm.
 //
 // The primary use of this package is inside other packages that provide a more
 // portable interface to the system, such as "os", "time" and "net".  Use
 // those packages rather than this one if you can.
 //
 // For details of the functions and data types in this package consult
 // the manuals for the appropriate operating system.
 //
 // These calls return err == nil to indicate success; otherwise
 // err represents an operating system error describing the failure and
 // holds a value of type syscall.ErrorString.
 package plan9 // import "golang.org/x/sys/plan9"
 import (
 	"bytes"
 	"strings"
 	"unsafe"
 	"golang.org/x/sys/internal/unsafeheader"
 )
 // ByteSliceFromString returns a NUL-terminated slice of bytes
 // containing the text of s. If s contains a NUL byte at any
 // location, it returns (nil, EINVAL).
 func ByteSliceFromString(s string) ([]byte, error) {
 	if strings.IndexByte(s, 0) != -1 {
 		return nil, EINVAL
 	}
 	a := make([]byte, len(s)+1)
 	copy(a, s)
 	return a, nil
 }
 // BytePtrFromString returns a pointer to a NUL-terminated array of
 // bytes containing the text of s. If s contains a NUL byte at any
 // location, it returns (nil, EINVAL).
 func BytePtrFromString(s string) (*byte, error) {
 	a, err := ByteSliceFromString(s)
 	if err != nil {
 		return nil, err
 	}
 	return &a[0], nil
 }
 // ByteSliceToString returns a string form of the text represented by the slice s, with a terminating NUL and any
 // bytes after the NUL removed.
 func ByteSliceToString(s []byte) string {
 	if i := bytes.IndexByte(s, 0); i != -1 {
 		s = s[:i]
 	}
 	return string(s)
 }
 // BytePtrToString takes a pointer to a sequence of text and returns the corresponding string.
 // If the pointer is nil, it returns the empty string. It assumes that the text sequence is terminated
 // at a zero byte; if the zero byte is not present, the program may crash.
 func BytePtrToString(p *byte) string {
 	if p == nil {
 		return ""
 	}
 	if *p == 0 {
 		return ""
 	}
 	// Find NUL terminator.
 	n := 0
 	for ptr := unsafe.Pointer(p); *(*byte)(ptr) != 0; n++ {
 		ptr = unsafe.Pointer(uintptr(ptr) + 1)
 	}
 	var s []byte
 	h := (*unsafeheader.Slice)(unsafe.Pointer(&s))
 	h.Data = unsafe.Pointer(p)
 	h.Len = n
 	h.Cap = n
 	return string(s)
 }
 // Single-word zero for use when we need a valid pointer to 0 bytes.
 // See mksyscall.pl.
 var _zero uintptr
 func (ts *Timespec) Unix() (sec int64, nsec int64) {
 	return int64(ts.Sec), int64(ts.Nsec)
 }
 func (tv *Timeval) Unix() (sec int64, nsec int64) {
 	return int64(tv.Sec), int64(tv.Usec) * 1000
 }
 func (ts *Timespec) Nano() int64 {
 	return int64(ts.Sec)*1e9 + int64(ts.Nsec)
 }
 func (tv *Timeval) Nano() int64 {
 	return int64(tv.Sec)*1e9 + int64(tv.Usec)*1000
 }
 // use is a no-op, but the compiler cannot see that it is.
 // Calling use(p) ensures that p is kept live until that point.
 //go:noescape
 func use(p unsafe.Pointer)
--- a/vendor/golang.org/x/sys/plan9/syscall_plan9.go
+++ b/vendor/golang.org/x/sys/plan9/syscall_plan9.go
@ -0,0 +1,349 @@
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // Plan 9 system calls.
 // This file is compiled as ordinary Go code,
 // but it is also input to mksyscall,
 // which parses the //sys lines and generates system call stubs.
 // Note that sometimes we use a lowercase //sys name and
 // wrap it in our own nicer implementation.
 package plan9
 import (
 	"bytes"
 	"syscall"
 	"unsafe"
 )
 // A Note is a string describing a process note.
 // It implements the os.Signal interface.
 type Note string
 func (n Note) Signal() {}
 func (n Note) String() string {
 	return string(n)
 }
 var (
 	Stdin  = 0
 	Stdout = 1
 	Stderr = 2
 )
 // For testing: clients can set this flag to force
 // creation of IPv6 sockets to return EAFNOSUPPORT.
 var SocketDisableIPv6 bool
 func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.ErrorString)
 func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.ErrorString)
 func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)
 func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)
 func atoi(b []byte) (n uint) {
 	n = 0
 	for i := 0; i < len(b); i++ {
 		n = n*10 + uint(b[i]-'0')
 	}
 	return
 }
 func cstring(s []byte) string {
 	i := bytes.IndexByte(s, 0)
 	if i == -1 {
 		i = len(s)
 	}
 	return string(s[:i])
 }
 func errstr() string {
 	var buf [ERRMAX]byte
 	RawSyscall(SYS_ERRSTR, uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)), 0)
 	buf[len(buf)-1] = 0
 	return cstring(buf[:])
 }
 // Implemented in assembly to import from runtime.
 func exit(code int)
 func Exit(code int) { exit(code) }
 func readnum(path string) (uint, error) {
 	var b [12]byte
 	fd, e := Open(path, O_RDONLY)
 	if e != nil {
 		return 0, e
 	}
 	defer Close(fd)
 	n, e := Pread(fd, b[:], 0)
 	if e != nil {
 		return 0, e
 	}
 	m := 0
 	for ; m < n && b[m] == ' '; m++ {
 	}
 	return atoi(b[m : n-1]), nil
 }
 func Getpid() (pid int) {
 	n, _ := readnum("#c/pid")
 	return int(n)
 }
 func Getppid() (ppid int) {
 	n, _ := readnum("#c/ppid")
 	return int(n)
 }
 func Read(fd int, p []byte) (n int, err error) {
 	return Pread(fd, p, -1)
 }
 func Write(fd int, p []byte) (n int, err error) {
 	return Pwrite(fd, p, -1)
 }
 var ioSync int64
 //sys	fd2path(fd int, buf []byte) (err error)
 func Fd2path(fd int) (path string, err error) {
 	var buf [512]byte
 	e := fd2path(fd, buf[:])
 	if e != nil {
 		return "", e
 	}
 	return cstring(buf[:]), nil
 }
 //sys	pipe(p *[2]int32) (err error)
 func Pipe(p []int) (err error) {
 	if len(p) != 2 {
 		return syscall.ErrorString("bad arg in system call")
 	}
 	var pp [2]int32
 	err = pipe(&pp)
 	p[0] = int(pp[0])
 	p[1] = int(pp[1])
 	return
 }
 // Underlying system call writes to newoffset via pointer.
 // Implemented in assembly to avoid allocation.
 func seek(placeholder uintptr, fd int, offset int64, whence int) (newoffset int64, err string)
 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
 	newoffset, e := seek(0, fd, offset, whence)
 	if newoffset == -1 {
 		err = syscall.ErrorString(e)
 	}
 	return
 }
 func Mkdir(path string, mode uint32) (err error) {
 	fd, err := Create(path, O_RDONLY, DMDIR|mode)
 	if fd != -1 {
 		Close(fd)
 	}
 	return
 }
 type Waitmsg struct {
 	Pid  int
 	Time [3]uint32
 	Msg  string
 }
 func (w Waitmsg) Exited() bool   { return true }
 func (w Waitmsg) Signaled() bool { return false }
 func (w Waitmsg) ExitStatus() int {
 	if len(w.Msg) == 0 {
 		// a normal exit returns no message
 		return 0
 	}
 	return 1
 }
 //sys	await(s []byte) (n int, err error)
 func Await(w *Waitmsg) (err error) {
 	var buf [512]byte
 	var f [5][]byte
 	n, err := await(buf[:])
 	if err != nil || w == nil {
 		return
 	}
 	nf := 0
 	p := 0
 	for i := 0; i < n && nf < len(f)-1; i++ {
 		if buf[i] == ' ' {
 			f[nf] = buf[p:i]
 			p = i + 1
 			nf++
 		}
 	}
 	f[nf] = buf[p:]
 	nf++
 	if nf != len(f) {
 		return syscall.ErrorString("invalid wait message")
 	}
 	w.Pid = int(atoi(f[0]))
 	w.Time[0] = uint32(atoi(f[1]))
 	w.Time[1] = uint32(atoi(f[2]))
 	w.Time[2] = uint32(atoi(f[3]))
 	w.Msg = cstring(f[4])
 	if w.Msg == "''" {
 		// await() returns '' for no error
 		w.Msg = ""
 	}
 	return
 }
 func Unmount(name, old string) (err error) {
 	fixwd()
 	oldp, err := BytePtrFromString(old)
 	if err != nil {
 		return err
 	}
 	oldptr := uintptr(unsafe.Pointer(oldp))
 	var r0 uintptr
 	var e syscall.ErrorString
 	// bind(2) man page: If name is zero, everything bound or mounted upon old is unbound or unmounted.
 	if name == "" {
 		r0, _, e = Syscall(SYS_UNMOUNT, _zero, oldptr, 0)
 	} else {
 		namep, err := BytePtrFromString(name)
 		if err != nil {
 			return err
 		}
 		r0, _, e = Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(namep)), oldptr, 0)
 	}
 	if int32(r0) == -1 {
 		err = e
 	}
 	return
 }
 func Fchdir(fd int) (err error) {
 	path, err := Fd2path(fd)
 	if err != nil {
 		return
 	}
 	return Chdir(path)
 }
 type Timespec struct {
 	Sec  int32
 	Nsec int32
 }
 type Timeval struct {
 	Sec  int32
 	Usec int32
 }
 func NsecToTimeval(nsec int64) (tv Timeval) {
 	nsec += 999 // round up to microsecond
 	tv.Usec = int32(nsec % 1e9 / 1e3)
 	tv.Sec = int32(nsec / 1e9)
 	return
 }
 func nsec() int64 {
 	var scratch int64
 	r0, _, _ := Syscall(SYS_NSEC, uintptr(unsafe.Pointer(&scratch)), 0, 0)
 	// TODO(aram): remove hack after I fix _nsec in the pc64 kernel.
 	if r0 == 0 {
 		return scratch
 	}
 	return int64(r0)
 }
 func Gettimeofday(tv *Timeval) error {
 	nsec := nsec()
 	*tv = NsecToTimeval(nsec)
 	return nil
 }
 func Getpagesize() int { return 0x1000 }
 func Getegid() (egid int) { return -1 }
 func Geteuid() (euid int) { return -1 }
 func Getgid() (gid int)   { return -1 }
 func Getuid() (uid int)   { return -1 }
 func Getgroups() (gids []int, err error) {
 	return make([]int, 0), nil
 }
 //sys	open(path string, mode int) (fd int, err error)
 func Open(path string, mode int) (fd int, err error) {
 	fixwd()
 	return open(path, mode)
 }
 //sys	create(path string, mode int, perm uint32) (fd int, err error)
 func Create(path string, mode int, perm uint32) (fd int, err error) {
 	fixwd()
 	return create(path, mode, perm)
 }
 //sys	remove(path string) (err error)
 func Remove(path string) error {
 	fixwd()
 	return remove(path)
 }
 //sys	stat(path string, edir []byte) (n int, err error)
 func Stat(path string, edir []byte) (n int, err error) {
 	fixwd()
 	return stat(path, edir)
 }
 //sys	bind(name string, old string, flag int) (err error)
 func Bind(name string, old string, flag int) (err error) {
 	fixwd()
 	return bind(name, old, flag)
 }
 //sys	mount(fd int, afd int, old string, flag int, aname string) (err error)
 func Mount(fd int, afd int, old string, flag int, aname string) (err error) {
 	fixwd()
 	return mount(fd, afd, old, flag, aname)
 }
 //sys	wstat(path string, edir []byte) (err error)
 func Wstat(path string, edir []byte) (err error) {
 	fixwd()
 	return wstat(path, edir)
 }
 //sys	chdir(path string) (err error)
 //sys	Dup(oldfd int, newfd int) (fd int, err error)
 //sys	Pread(fd int, p []byte, offset int64) (n int, err error)
 //sys	Pwrite(fd int, p []byte, offset int64) (n int, err error)
 //sys	Close(fd int) (err error)
 //sys	Fstat(fd int, edir []byte) (n int, err error)
 //sys	Fwstat(fd int, edir []byte) (err error)
--- a/vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go
+++ b/vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go
@ -0,0 +1,284 @@
 // go run mksyscall.go -l32 -plan9 -tags plan9,386 syscall_plan9.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 // +build plan9,386
 package plan9
 import "unsafe"
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func fd2path(fd int, buf []byte) (err error) {
 	var _p0 unsafe.Pointer
 	if len(buf) > 0 {
 		_p0 = unsafe.Pointer(&buf[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_FD2PATH, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func pipe(p *[2]int32) (err error) {
 	r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func await(s []byte) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(s) > 0 {
 		_p0 = unsafe.Pointer(&s[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_AWAIT, uintptr(_p0), uintptr(len(s)), 0)
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func open(path string, mode int) (fd int, err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	fd = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func create(path string, mode int, perm uint32) (fd int, err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
 	fd = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func remove(path string) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func stat(path string, edir []byte) (n int, err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	var _p1 unsafe.Pointer
 	if len(edir) > 0 {
 		_p1 = unsafe.Pointer(&edir[0])
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func bind(name string, old string, flag int) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(name)
 	if err != nil {
 		return
 	}
 	var _p1 *byte
 	_p1, err = BytePtrFromString(old)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_BIND, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func mount(fd int, afd int, old string, flag int, aname string) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(old)
 	if err != nil {
 		return
 	}
 	var _p1 *byte
 	_p1, err = BytePtrFromString(aname)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall6(SYS_MOUNT, uintptr(fd), uintptr(afd), uintptr(unsafe.Pointer(_p0)), uintptr(flag), uintptr(unsafe.Pointer(_p1)), 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func wstat(path string, edir []byte) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	var _p1 unsafe.Pointer
 	if len(edir) > 0 {
 		_p1 = unsafe.Pointer(&edir[0])
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_WSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func chdir(path string) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Dup(oldfd int, newfd int) (fd int, err error) {
 	r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), uintptr(newfd), 0)
 	fd = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(p) > 0 {
 		_p0 = unsafe.Pointer(&p[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(p) > 0 {
 		_p0 = unsafe.Pointer(&p[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Close(fd int) (err error) {
 	r0, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Fstat(fd int, edir []byte) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(edir) > 0 {
 		_p0 = unsafe.Pointer(&edir[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Fwstat(fd int, edir []byte) (err error) {
 	var _p0 unsafe.Pointer
 	if len(edir) > 0 {
 		_p0 = unsafe.Pointer(&edir[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
--- a/vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go
+++ b/vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go
@ -0,0 +1,284 @@
 // go run mksyscall.go -l32 -plan9 -tags plan9,amd64 syscall_plan9.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 // +build plan9,amd64
 package plan9
 import "unsafe"
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func fd2path(fd int, buf []byte) (err error) {
 	var _p0 unsafe.Pointer
 	if len(buf) > 0 {
 		_p0 = unsafe.Pointer(&buf[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_FD2PATH, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func pipe(p *[2]int32) (err error) {
 	r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func await(s []byte) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(s) > 0 {
 		_p0 = unsafe.Pointer(&s[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_AWAIT, uintptr(_p0), uintptr(len(s)), 0)
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func open(path string, mode int) (fd int, err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	fd = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func create(path string, mode int, perm uint32) (fd int, err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
 	fd = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func remove(path string) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func stat(path string, edir []byte) (n int, err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	var _p1 unsafe.Pointer
 	if len(edir) > 0 {
 		_p1 = unsafe.Pointer(&edir[0])
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func bind(name string, old string, flag int) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(name)
 	if err != nil {
 		return
 	}
 	var _p1 *byte
 	_p1, err = BytePtrFromString(old)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_BIND, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func mount(fd int, afd int, old string, flag int, aname string) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(old)
 	if err != nil {
 		return
 	}
 	var _p1 *byte
 	_p1, err = BytePtrFromString(aname)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall6(SYS_MOUNT, uintptr(fd), uintptr(afd), uintptr(unsafe.Pointer(_p0)), uintptr(flag), uintptr(unsafe.Pointer(_p1)), 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func wstat(path string, edir []byte) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	var _p1 unsafe.Pointer
 	if len(edir) > 0 {
 		_p1 = unsafe.Pointer(&edir[0])
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_WSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func chdir(path string) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Dup(oldfd int, newfd int) (fd int, err error) {
 	r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), uintptr(newfd), 0)
 	fd = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(p) > 0 {
 		_p0 = unsafe.Pointer(&p[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(p) > 0 {
 		_p0 = unsafe.Pointer(&p[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Close(fd int) (err error) {
 	r0, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Fstat(fd int, edir []byte) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(edir) > 0 {
 		_p0 = unsafe.Pointer(&edir[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Fwstat(fd int, edir []byte) (err error) {
 	var _p0 unsafe.Pointer
 	if len(edir) > 0 {
 		_p0 = unsafe.Pointer(&edir[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
--- a/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go
+++ b/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go
@ -0,0 +1,284 @@
 // go run mksyscall.go -l32 -plan9 -tags plan9,arm syscall_plan9.go
 // Code generated by the command above; see README.md. DO NOT EDIT.
 // +build plan9,arm
 package plan9
 import "unsafe"
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func fd2path(fd int, buf []byte) (err error) {
 	var _p0 unsafe.Pointer
 	if len(buf) > 0 {
 		_p0 = unsafe.Pointer(&buf[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_FD2PATH, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func pipe(p *[2]int32) (err error) {
 	r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func await(s []byte) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(s) > 0 {
 		_p0 = unsafe.Pointer(&s[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_AWAIT, uintptr(_p0), uintptr(len(s)), 0)
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func open(path string, mode int) (fd int, err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 	fd = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func create(path string, mode int, perm uint32) (fd int, err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
 	fd = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func remove(path string) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func stat(path string, edir []byte) (n int, err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	var _p1 unsafe.Pointer
 	if len(edir) > 0 {
 		_p1 = unsafe.Pointer(&edir[0])
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func bind(name string, old string, flag int) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(name)
 	if err != nil {
 		return
 	}
 	var _p1 *byte
 	_p1, err = BytePtrFromString(old)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_BIND, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func mount(fd int, afd int, old string, flag int, aname string) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(old)
 	if err != nil {
 		return
 	}
 	var _p1 *byte
 	_p1, err = BytePtrFromString(aname)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall6(SYS_MOUNT, uintptr(fd), uintptr(afd), uintptr(unsafe.Pointer(_p0)), uintptr(flag), uintptr(unsafe.Pointer(_p1)), 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func wstat(path string, edir []byte) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	var _p1 unsafe.Pointer
 	if len(edir) > 0 {
 		_p1 = unsafe.Pointer(&edir[0])
 	} else {
 		_p1 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_WSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func chdir(path string) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
 	if err != nil {
 		return
 	}
 	r0, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Dup(oldfd int, newfd int) (fd int, err error) {
 	r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), uintptr(newfd), 0)
 	fd = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Pread(fd int, p []byte, offset int64) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(p) > 0 {
 		_p0 = unsafe.Pointer(&p[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(p) > 0 {
 		_p0 = unsafe.Pointer(&p[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Close(fd int) (err error) {
 	r0, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Fstat(fd int, edir []byte) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(edir) > 0 {
 		_p0 = unsafe.Pointer(&edir[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
 	n = int(r0)
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 func Fwstat(fd int, edir []byte) (err error) {
 	var _p0 unsafe.Pointer
 	if len(edir) > 0 {
 		_p0 = unsafe.Pointer(&edir[0])
 	} else {
 		_p0 = unsafe.Pointer(&_zero)
 	}
 	r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
 	if int32(r0) == -1 {
 		err = e1
 	}
 	return
 }
--- a/vendor/golang.org/x/sys/plan9/zsysnum_plan9.go
+++ b/vendor/golang.org/x/sys/plan9/zsysnum_plan9.go
@ -0,0 +1,49 @@
 // mksysnum_plan9.sh /opt/plan9/sys/src/libc/9syscall/sys.h
 // MACHINE GENERATED BY THE ABOVE COMMAND; DO NOT EDIT
 package plan9
 const (
 	SYS_SYSR1       = 0
 	SYS_BIND        = 2
 	SYS_CHDIR       = 3
 	SYS_CLOSE       = 4
 	SYS_DUP         = 5
 	SYS_ALARM       = 6
 	SYS_EXEC        = 7
 	SYS_EXITS       = 8
 	SYS_FAUTH       = 10
 	SYS_SEGBRK      = 12
 	SYS_OPEN        = 14
 	SYS_OSEEK       = 16
 	SYS_SLEEP       = 17
 	SYS_RFORK       = 19
 	SYS_PIPE        = 21
 	SYS_CREATE      = 22
 	SYS_FD2PATH     = 23
 	SYS_BRK_        = 24
 	SYS_REMOVE      = 25
 	SYS_NOTIFY      = 28
 	SYS_NOTED       = 29
 	SYS_SEGATTACH   = 30
 	SYS_SEGDETACH   = 31
 	SYS_SEGFREE     = 32
 	SYS_SEGFLUSH    = 33
 	SYS_RENDEZVOUS  = 34
 	SYS_UNMOUNT     = 35
 	SYS_SEMACQUIRE  = 37
 	SYS_SEMRELEASE  = 38
 	SYS_SEEK        = 39
 	SYS_FVERSION    = 40
 	SYS_ERRSTR      = 41
 	SYS_STAT        = 42
 	SYS_FSTAT       = 43
 	SYS_WSTAT       = 44
 	SYS_FWSTAT      = 45
 	SYS_MOUNT       = 46
 	SYS_AWAIT       = 47
 	SYS_PREAD       = 50
 	SYS_PWRITE      = 51
 	SYS_TSEMACQUIRE = 52
 	SYS_NSEC        = 53
 )
--- a/vendor/golang.org/x/sys/unix/.gitignore
+++ b/vendor/golang.org/x/sys/unix/.gitignore
@ -0,0 +1,2 @@
 _obj/
 unix.test
--- a/vendor/golang.org/x/sys/unix/README.md
+++ b/vendor/golang.org/x/sys/unix/README.md
@ -0,0 +1,184 @@
 # Building `sys/unix`
 The sys/unix package provides access to the raw system call interface of the
 underlying operating system. See: https://godoc.org/golang.org/x/sys/unix
 Porting Go to a new architecture/OS combination or adding syscalls, types, or
 constants to an existing architecture/OS pair requires some manual effort;
 however, there are tools that automate much of the process.
 ## Build Systems
 There are currently two ways we generate the necessary files. We are currently
 migrating the build system to use containers so the builds are reproducible.
 This is being done on an OS-by-OS basis. Please update this documentation as
 components of the build system change.
 ### Old Build System (currently for `GOOS != "linux"`)
 The old build system generates the Go files based on the C header files
 present on your system. This means that files
 for a given GOOS/GOARCH pair must be generated on a system with that OS and
 architecture. This also means that the generated code can differ from system
 to system, based on differences in the header files.
 To avoid this, if you are using the old build system, only generate the Go
 files on an installation with unmodified header files. It is also important to
 keep track of which version of the OS the files were generated from (ex.
 Darwin 14 vs Darwin 15). This makes it easier to track the progress of changes
 and have each OS upgrade correspond to a single change.
 To build the files for your current OS and architecture, make sure GOOS and
 GOARCH are set correctly and run `mkall.sh`. This will generate the files for
 your specific system. Running `mkall.sh -n` shows the commands that will be run.
 Requirements: bash, go
 ### New Build System (currently for `GOOS == "linux"`)
 The new build system uses a Docker container to generate the go files directly
 from source checkouts of the kernel and various system libraries. This means
 that on any platform that supports Docker, all the files using the new build
 system can be generated at once, and generated files will not change based on
 what the person running the scripts has installed on their computer.
 The OS specific files for the new build system are located in the `${GOOS}`
 directory, and the build is coordinated by the `${GOOS}/mkall.go` program. When
 the kernel or system library updates, modify the Dockerfile at
 `${GOOS}/Dockerfile` to checkout the new release of the source.
 To build all the files under the new build system, you must be on an amd64/Linux
 system and have your GOOS and GOARCH set accordingly. Running `mkall.sh` will
 then generate all of the files for all of the GOOS/GOARCH pairs in the new build
 system. Running `mkall.sh -n` shows the commands that will be run.
 Requirements: bash, go, docker
 ## Component files
 This section describes the various files used in the code generation process.
 It also contains instructions on how to modify these files to add a new
 architecture/OS or to add additional syscalls, types, or constants. Note that
 if you are using the new build system, the scripts/programs cannot be called normally.
 They must be called from within the docker container.
 ### asm files
 The hand-written assembly file at `asm_${GOOS}_${GOARCH}.s` implements system
 call dispatch. There are three entry points:
 ```
  func Syscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)
  func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)
  func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)
 ```
 The first and second are the standard ones; they differ only in how many
 arguments can be passed to the kernel. The third is for low-level use by the
 ForkExec wrapper. Unlike the first two, it does not call into the scheduler to
 let it know that a system call is running.
 When porting Go to a new architecture/OS, this file must be implemented for
 each GOOS/GOARCH pair.
 ### mksysnum
 Mksysnum is a Go program located at `${GOOS}/mksysnum.go` (or `mksysnum_${GOOS}.go`
 for the old system). This program takes in a list of header files containing the
 syscall number declarations and parses them to produce the corresponding list of
 Go numeric constants. See `zsysnum_${GOOS}_${GOARCH}.go` for the generated
 constants.
 Adding new syscall numbers is mostly done by running the build on a sufficiently
 new installation of the target OS (or updating the source checkouts for the
 new build system). However, depending on the OS, you may need to update the
 parsing in mksysnum.
 ### mksyscall.go
 The `syscall.go`, `syscall_${GOOS}.go`, `syscall_${GOOS}_${GOARCH}.go` are
 hand-written Go files which implement system calls (for unix, the specific OS,
 or the specific OS/Architecture pair respectively) that need special handling
 and list `//sys` comments giving prototypes for ones that can be generated.
 The mksyscall.go program takes the `//sys` and `//sysnb` comments and converts
 them into syscalls. This requires the name of the prototype in the comment to
 match a syscall number in the `zsysnum_${GOOS}_${GOARCH}.go` file. The function
 prototype can be exported (capitalized) or not.
 Adding a new syscall often just requires adding a new `//sys` function prototype
 with the desired arguments and a capitalized name so it is exported. However, if
 you want the interface to the syscall to be different, often one will make an
 unexported `//sys` prototype, and then write a custom wrapper in
 `syscall_${GOOS}.go`.
 ### types files
 For each OS, there is a hand-written Go file at `${GOOS}/types.go` (or
 `types_${GOOS}.go` on the old system). This file includes standard C headers and
 creates Go type aliases to the corresponding C types. The file is then fed
 through godef to get the Go compatible definitions. Finally, the generated code
 is fed though mkpost.go to format the code correctly and remove any hidden or
 private identifiers. This cleaned-up code is written to
 `ztypes_${GOOS}_${GOARCH}.go`.
 The hardest part about preparing this file is figuring out which headers to
 include and which symbols need to be `#define`d to get the actual data
 structures that pass through to the kernel system calls. Some C libraries
 preset alternate versions for binary compatibility and translate them on the
 way in and out of system calls, but there is almost always a `#define` that can
 get the real ones.
 See `types_darwin.go` and `linux/types.go` for examples.
 To add a new type, add in the necessary include statement at the top of the
 file (if it is not already there) and add in a type alias line. Note that if
 your type is significantly different on different architectures, you may need
 some `#if/#elif` macros in your include statements.
 ### mkerrors.sh
 This script is used to generate the system's various constants. This doesn't
 just include the error numbers and error strings, but also the signal numbers
 and a wide variety of miscellaneous constants. The constants come from the list
 of include files in the `includes_${uname}` variable. A regex then picks out
 the desired `#define` statements, and generates the corresponding Go constants.
 The error numbers and strings are generated from `#include <errno.h>`, and the
 signal numbers and strings are generated from `#include <signal.h>`. All of
 these constants are written to `zerrors_${GOOS}_${GOARCH}.go` via a C program,
 `_errors.c`, which prints out all the constants.
 To add a constant, add the header that includes it to the appropriate variable.
 Then, edit the regex (if necessary) to match the desired constant. Avoid making
 the regex too broad to avoid matching unintended constants.
 ### mkmerge.go
 This program is used to extract duplicate const, func, and type declarations
 from the generated architecture-specific files listed below, and merge these
 into a common file for each OS.
 The merge is performed in the following steps:
 1. Construct the set of common code that is idential in all architecture-specific files.
 2. Write this common code to the merged file.
 3. Remove the common code from all architecture-specific files.
 ## Generated files
 ### `zerrors_${GOOS}_${GOARCH}.go`
 A file containing all of the system's generated error numbers, error strings,
 signal numbers, and constants. Generated by `mkerrors.sh` (see above).
 ### `zsyscall_${GOOS}_${GOARCH}.go`
 A file containing all the generated syscalls for a specific GOOS and GOARCH.
 Generated by `mksyscall.go` (see above).
 ### `zsysnum_${GOOS}_${GOARCH}.go`
 A list of numeric constants for all the syscall number of the specific GOOS
 and GOARCH. Generated by mksysnum (see above).
 ### `ztypes_${GOOS}_${GOARCH}.go`
 A file containing Go types for passing into (or returning from) syscalls.
 Generated by godefs and the types file (see above).
--- a/vendor/golang.org/x/sys/unix/affinity_linux.go
+++ b/vendor/golang.org/x/sys/unix/affinity_linux.go
@ -0,0 +1,86 @@
 // Copyright 2018 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // CPU affinity functions
 package unix
 import (
 	"math/bits"
 	"unsafe"
 )
 const cpuSetSize = _CPU_SETSIZE / _NCPUBITS
 // CPUSet represents a CPU affinity mask.
 type CPUSet [cpuSetSize]cpuMask
 func schedAffinity(trap uintptr, pid int, set *CPUSet) error {
 	_, _, e := RawSyscall(trap, uintptr(pid), uintptr(unsafe.Sizeof(*set)), uintptr(unsafe.Pointer(set)))
 	if e != 0 {
 		return errnoErr(e)
 	}
 	return nil
 }
 // SchedGetaffinity gets the CPU affinity mask of the thread specified by pid.
 // If pid is 0 the calling thread is used.
 func SchedGetaffinity(pid int, set *CPUSet) error {
 	return schedAffinity(SYS_SCHED_GETAFFINITY, pid, set)
 }
 // SchedSetaffinity sets the CPU affinity mask of the thread specified by pid.
 // If pid is 0 the calling thread is used.
 func SchedSetaffinity(pid int, set *CPUSet) error {
 	return schedAffinity(SYS_SCHED_SETAFFINITY, pid, set)
 }
 // Zero clears the set s, so that it contains no CPUs.
 func (s *CPUSet) Zero() {
 	for i := range s {
 		s[i] = 0
 	}
 }
 func cpuBitsIndex(cpu int) int {
 	return cpu / _NCPUBITS
 }
 func cpuBitsMask(cpu int) cpuMask {
 	return cpuMask(1 << (uint(cpu) % _NCPUBITS))
 }
 // Set adds cpu to the set s.
 func (s *CPUSet) Set(cpu int) {
 	i := cpuBitsIndex(cpu)
 	if i < len(s) {
 		s[i] |= cpuBitsMask(cpu)
 	}
 }
 // Clear removes cpu from the set s.
 func (s *CPUSet) Clear(cpu int) {
 	i := cpuBitsIndex(cpu)
 	if i < len(s) {
 		s[i] &^= cpuBitsMask(cpu)
 	}
 }
 // IsSet reports whether cpu is in the set s.
 func (s *CPUSet) IsSet(cpu int) bool {
 	i := cpuBitsIndex(cpu)
 	if i < len(s) {
 		return s[i]&cpuBitsMask(cpu) != 0
 	}
 	return false
 }
 // Count returns the number of CPUs in the set s.
 func (s *CPUSet) Count() int {
 	c := 0
 	for _, b := range s {
 		c += bits.OnesCount64(uint64(b))
 	}
 	return c
 }
--- a/vendor/golang.org/x/sys/unix/aliases.go
+++ b/vendor/golang.org/x/sys/unix/aliases.go
@ -0,0 +1,15 @@
 // Copyright 2018 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos) && go1.9
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos
 // +build go1.9
 package unix
 import "syscall"
 type Signal = syscall.Signal
 type Errno = syscall.Errno
 type SysProcAttr = syscall.SysProcAttr
--- a/vendor/golang.org/x/sys/unix/asm_aix_ppc64.s
+++ b/vendor/golang.org/x/sys/unix/asm_aix_ppc64.s
@ -0,0 +1,18 @@
 // Copyright 2018 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build gc
 // +build gc
 #include "textflag.h"
 //
 // System calls for ppc64, AIX are implemented in runtime/syscall_aix.go
 //
 TEXT ·syscall6(SB),NOSPLIT,$0-88
 	JMP	syscall·syscall6(SB)
 TEXT ·rawSyscall6(SB),NOSPLIT,$0-88
 	JMP	syscall·rawSyscall6(SB)
--- a/vendor/golang.org/x/sys/unix/asm_bsd_386.s
+++ b/vendor/golang.org/x/sys/unix/asm_bsd_386.s
@ -0,0 +1,29 @@
 // Copyright 2021 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build (freebsd || netbsd || openbsd) && gc
 // +build freebsd netbsd openbsd
 // +build gc
 #include "textflag.h"
 // System call support for 386 BSD
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT	·Syscall(SB),NOSPLIT,$0-28
 	JMP	syscall·Syscall(SB)
 TEXT	·Syscall6(SB),NOSPLIT,$0-40
 	JMP	syscall·Syscall6(SB)
 TEXT	·Syscall9(SB),NOSPLIT,$0-52
 	JMP	syscall·Syscall9(SB)
 TEXT	·RawSyscall(SB),NOSPLIT,$0-28
 	JMP	syscall·RawSyscall(SB)
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
 	JMP	syscall·RawSyscall6(SB)
--- a/vendor/golang.org/x/sys/unix/asm_bsd_amd64.s
+++ b/vendor/golang.org/x/sys/unix/asm_bsd_amd64.s
@ -0,0 +1,29 @@
 // Copyright 2021 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build (darwin || dragonfly || freebsd || netbsd || openbsd) && gc
 // +build darwin dragonfly freebsd netbsd openbsd
 // +build gc
 #include "textflag.h"
 // System call support for AMD64 BSD
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT	·Syscall(SB),NOSPLIT,$0-56
 	JMP	syscall·Syscall(SB)
 TEXT	·Syscall6(SB),NOSPLIT,$0-80
 	JMP	syscall·Syscall6(SB)
 TEXT	·Syscall9(SB),NOSPLIT,$0-104
 	JMP	syscall·Syscall9(SB)
 TEXT	·RawSyscall(SB),NOSPLIT,$0-56
 	JMP	syscall·RawSyscall(SB)
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
 	JMP	syscall·RawSyscall6(SB)
--- a/vendor/golang.org/x/sys/unix/asm_bsd_arm.s
+++ b/vendor/golang.org/x/sys/unix/asm_bsd_arm.s
@ -0,0 +1,29 @@
 // Copyright 2021 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build (freebsd || netbsd || openbsd) && gc
 // +build freebsd netbsd openbsd
 // +build gc
 #include "textflag.h"
 // System call support for ARM BSD
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT	·Syscall(SB),NOSPLIT,$0-28
 	B	syscall·Syscall(SB)
 TEXT	·Syscall6(SB),NOSPLIT,$0-40
 	B	syscall·Syscall6(SB)
 TEXT	·Syscall9(SB),NOSPLIT,$0-52
 	B	syscall·Syscall9(SB)
 TEXT	·RawSyscall(SB),NOSPLIT,$0-28
 	B	syscall·RawSyscall(SB)
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
 	B	syscall·RawSyscall6(SB)
--- a/vendor/golang.org/x/sys/unix/asm_bsd_arm64.s
+++ b/vendor/golang.org/x/sys/unix/asm_bsd_arm64.s
@ -0,0 +1,29 @@
 // Copyright 2021 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build (darwin || freebsd || netbsd || openbsd) && gc
 // +build darwin freebsd netbsd openbsd
 // +build gc
 #include "textflag.h"
 // System call support for ARM64 BSD
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT	·Syscall(SB),NOSPLIT,$0-56
 	JMP	syscall·Syscall(SB)
 TEXT	·Syscall6(SB),NOSPLIT,$0-80
 	JMP	syscall·Syscall6(SB)
 TEXT	·Syscall9(SB),NOSPLIT,$0-104
 	JMP	syscall·Syscall9(SB)
 TEXT	·RawSyscall(SB),NOSPLIT,$0-56
 	JMP	syscall·RawSyscall(SB)
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
 	JMP	syscall·RawSyscall6(SB)
--- a/vendor/golang.org/x/sys/unix/asm_linux_386.s
+++ b/vendor/golang.org/x/sys/unix/asm_linux_386.s
@ -0,0 +1,66 @@
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build gc
 // +build gc
 #include "textflag.h"
 //
 // System calls for 386, Linux
 //
 // See ../runtime/sys_linux_386.s for the reason why we always use int 0x80
 // instead of the glibc-specific "CALL 0x10(GS)".
 #define INVOKE_SYSCALL	INT	$0x80
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT ·Syscall(SB),NOSPLIT,$0-28
 	JMP	syscall·Syscall(SB)
 TEXT ·Syscall6(SB),NOSPLIT,$0-40
 	JMP	syscall·Syscall6(SB)
 TEXT ·SyscallNoError(SB),NOSPLIT,$0-24
 	CALL	runtime·entersyscall(SB)
 	MOVL	trap+0(FP), AX  // syscall entry
 	MOVL	a1+4(FP), BX
 	MOVL	a2+8(FP), CX
 	MOVL	a3+12(FP), DX
 	MOVL	$0, SI
 	MOVL	$0, DI
 	INVOKE_SYSCALL
 	MOVL	AX, r1+16(FP)
 	MOVL	DX, r2+20(FP)
 	CALL	runtime·exitsyscall(SB)
 	RET
 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
 	JMP	syscall·RawSyscall(SB)
 TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
 	JMP	syscall·RawSyscall6(SB)
 TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24
 	MOVL	trap+0(FP), AX  // syscall entry
 	MOVL	a1+4(FP), BX
 	MOVL	a2+8(FP), CX
 	MOVL	a3+12(FP), DX
 	MOVL	$0, SI
 	MOVL	$0, DI
 	INVOKE_SYSCALL
 	MOVL	AX, r1+16(FP)
 	MOVL	DX, r2+20(FP)
 	RET
 TEXT ·socketcall(SB),NOSPLIT,$0-36
 	JMP	syscall·socketcall(SB)
 TEXT ·rawsocketcall(SB),NOSPLIT,$0-36
 	JMP	syscall·rawsocketcall(SB)
 TEXT ·seek(SB),NOSPLIT,$0-28
 	JMP	syscall·seek(SB)
--- a/vendor/golang.org/x/sys/unix/asm_linux_amd64.s
+++ b/vendor/golang.org/x/sys/unix/asm_linux_amd64.s
@ -0,0 +1,58 @@
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build gc
 // +build gc
 #include "textflag.h"
 //
 // System calls for AMD64, Linux
 //
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT ·Syscall(SB),NOSPLIT,$0-56
 	JMP	syscall·Syscall(SB)
 TEXT ·Syscall6(SB),NOSPLIT,$0-80
 	JMP	syscall·Syscall6(SB)
 TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
 	CALL	runtime·entersyscall(SB)
 	MOVQ	a1+8(FP), DI
 	MOVQ	a2+16(FP), SI
 	MOVQ	a3+24(FP), DX
 	MOVQ	$0, R10
 	MOVQ	$0, R8
 	MOVQ	$0, R9
 	MOVQ	trap+0(FP), AX	// syscall entry
 	SYSCALL
 	MOVQ	AX, r1+32(FP)
 	MOVQ	DX, r2+40(FP)
 	CALL	runtime·exitsyscall(SB)
 	RET
 TEXT ·RawSyscall(SB),NOSPLIT,$0-56
 	JMP	syscall·RawSyscall(SB)
 TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
 	JMP	syscall·RawSyscall6(SB)
 TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
 	MOVQ	a1+8(FP), DI
 	MOVQ	a2+16(FP), SI
 	MOVQ	a3+24(FP), DX
 	MOVQ	$0, R10
 	MOVQ	$0, R8
 	MOVQ	$0, R9
 	MOVQ	trap+0(FP), AX	// syscall entry
 	SYSCALL
 	MOVQ	AX, r1+32(FP)
 	MOVQ	DX, r2+40(FP)
 	RET
 TEXT ·gettimeofday(SB),NOSPLIT,$0-16
 	JMP	syscall·gettimeofday(SB)
--- a/vendor/golang.org/x/sys/unix/asm_linux_arm.s
+++ b/vendor/golang.org/x/sys/unix/asm_linux_arm.s
@ -0,0 +1,57 @@
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build gc
 // +build gc
 #include "textflag.h"
 //
 // System calls for arm, Linux
 //
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT ·Syscall(SB),NOSPLIT,$0-28
 	B	syscall·Syscall(SB)
 TEXT ·Syscall6(SB),NOSPLIT,$0-40
 	B	syscall·Syscall6(SB)
 TEXT ·SyscallNoError(SB),NOSPLIT,$0-24
 	BL	runtime·entersyscall(SB)
 	MOVW	trap+0(FP), R7
 	MOVW	a1+4(FP), R0
 	MOVW	a2+8(FP), R1
 	MOVW	a3+12(FP), R2
 	MOVW	$0, R3
 	MOVW	$0, R4
 	MOVW	$0, R5
 	SWI	$0
 	MOVW	R0, r1+16(FP)
 	MOVW	$0, R0
 	MOVW	R0, r2+20(FP)
 	BL	runtime·exitsyscall(SB)
 	RET
 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
 	B	syscall·RawSyscall(SB)
 TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
 	B	syscall·RawSyscall6(SB)
 TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24
 	MOVW	trap+0(FP), R7	// syscall entry
 	MOVW	a1+4(FP), R0
 	MOVW	a2+8(FP), R1
 	MOVW	a3+12(FP), R2
 	SWI	$0
 	MOVW	R0, r1+16(FP)
 	MOVW	$0, R0
 	MOVW	R0, r2+20(FP)
 	RET
 TEXT ·seek(SB),NOSPLIT,$0-28
 	B	syscall·seek(SB)
--- a/vendor/golang.org/x/sys/unix/asm_linux_arm64.s
+++ b/vendor/golang.org/x/sys/unix/asm_linux_arm64.s
@ -0,0 +1,53 @@
 // Copyright 2015 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build linux && arm64 && gc
 // +build linux
 // +build arm64
 // +build gc
 #include "textflag.h"
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT ·Syscall(SB),NOSPLIT,$0-56
 	B	syscall·Syscall(SB)
 TEXT ·Syscall6(SB),NOSPLIT,$0-80
 	B	syscall·Syscall6(SB)
 TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
 	BL	runtime·entersyscall(SB)
 	MOVD	a1+8(FP), R0
 	MOVD	a2+16(FP), R1
 	MOVD	a3+24(FP), R2
 	MOVD	$0, R3
 	MOVD	$0, R4
 	MOVD	$0, R5
 	MOVD	trap+0(FP), R8	// syscall entry
 	SVC
 	MOVD	R0, r1+32(FP)	// r1
 	MOVD	R1, r2+40(FP)	// r2
 	BL	runtime·exitsyscall(SB)
 	RET
 TEXT ·RawSyscall(SB),NOSPLIT,$0-56
 	B	syscall·RawSyscall(SB)
 TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
 	B	syscall·RawSyscall6(SB)
 TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
 	MOVD	a1+8(FP), R0
 	MOVD	a2+16(FP), R1
 	MOVD	a3+24(FP), R2
 	MOVD	$0, R3
 	MOVD	$0, R4
 	MOVD	$0, R5
 	MOVD	trap+0(FP), R8	// syscall entry
 	SVC
 	MOVD	R0, r1+32(FP)
 	MOVD	R1, r2+40(FP)
 	RET
--- a/vendor/golang.org/x/sys/unix/asm_linux_mips64x.s
+++ b/vendor/golang.org/x/sys/unix/asm_linux_mips64x.s
@ -0,0 +1,57 @@
 // Copyright 2015 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build linux && (mips64 || mips64le) && gc
 // +build linux
 // +build mips64 mips64le
 // +build gc
 #include "textflag.h"
 //
 // System calls for mips64, Linux
 //
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT ·Syscall(SB),NOSPLIT,$0-56
 	JMP	syscall·Syscall(SB)
 TEXT ·Syscall6(SB),NOSPLIT,$0-80
 	JMP	syscall·Syscall6(SB)
 TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
 	JAL	runtime·entersyscall(SB)
 	MOVV	a1+8(FP), R4
 	MOVV	a2+16(FP), R5
 	MOVV	a3+24(FP), R6
 	MOVV	R0, R7
 	MOVV	R0, R8
 	MOVV	R0, R9
 	MOVV	trap+0(FP), R2	// syscall entry
 	SYSCALL
 	MOVV	R2, r1+32(FP)
 	MOVV	R3, r2+40(FP)
 	JAL	runtime·exitsyscall(SB)
 	RET
 TEXT ·RawSyscall(SB),NOSPLIT,$0-56
 	JMP	syscall·RawSyscall(SB)
 TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
 	JMP	syscall·RawSyscall6(SB)
 TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
 	MOVV	a1+8(FP), R4
 	MOVV	a2+16(FP), R5
 	MOVV	a3+24(FP), R6
 	MOVV	R0, R7
 	MOVV	R0, R8
 	MOVV	R0, R9
 	MOVV	trap+0(FP), R2	// syscall entry
 	SYSCALL
 	MOVV	R2, r1+32(FP)
 	MOVV	R3, r2+40(FP)
 	RET
--- a/vendor/golang.org/x/sys/unix/asm_linux_mipsx.s
+++ b/vendor/golang.org/x/sys/unix/asm_linux_mipsx.s
@ -0,0 +1,55 @@
 // Copyright 2016 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build linux && (mips || mipsle) && gc
 // +build linux
 // +build mips mipsle
 // +build gc
 #include "textflag.h"
 //
 // System calls for mips, Linux
 //
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT ·Syscall(SB),NOSPLIT,$0-28
 	JMP syscall·Syscall(SB)
 TEXT ·Syscall6(SB),NOSPLIT,$0-40
 	JMP syscall·Syscall6(SB)
 TEXT ·Syscall9(SB),NOSPLIT,$0-52
 	JMP syscall·Syscall9(SB)
 TEXT ·SyscallNoError(SB),NOSPLIT,$0-24
 	JAL	runtime·entersyscall(SB)
 	MOVW	a1+4(FP), R4
 	MOVW	a2+8(FP), R5
 	MOVW	a3+12(FP), R6
 	MOVW	R0, R7
 	MOVW	trap+0(FP), R2	// syscall entry
 	SYSCALL
 	MOVW	R2, r1+16(FP)	// r1
 	MOVW	R3, r2+20(FP)	// r2
 	JAL	runtime·exitsyscall(SB)
 	RET
 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
 	JMP syscall·RawSyscall(SB)
 TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
 	JMP syscall·RawSyscall6(SB)
 TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24
 	MOVW	a1+4(FP), R4
 	MOVW	a2+8(FP), R5
 	MOVW	a3+12(FP), R6
 	MOVW	trap+0(FP), R2	// syscall entry
 	SYSCALL
 	MOVW	R2, r1+16(FP)
 	MOVW	R3, r2+20(FP)
 	RET
--- a/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s
+++ b/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s
@ -0,0 +1,45 @@
 // Copyright 2014 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build linux && (ppc64 || ppc64le) && gc
 // +build linux
 // +build ppc64 ppc64le
 // +build gc
 #include "textflag.h"
 //
 // System calls for ppc64, Linux
 //
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
 	BL	runtime·entersyscall(SB)
 	MOVD	a1+8(FP), R3
 	MOVD	a2+16(FP), R4
 	MOVD	a3+24(FP), R5
 	MOVD	R0, R6
 	MOVD	R0, R7
 	MOVD	R0, R8
 	MOVD	trap+0(FP), R9	// syscall entry
 	SYSCALL R9
 	MOVD	R3, r1+32(FP)
 	MOVD	R4, r2+40(FP)
 	BL	runtime·exitsyscall(SB)
 	RET
 TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
 	MOVD	a1+8(FP), R3
 	MOVD	a2+16(FP), R4
 	MOVD	a3+24(FP), R5
 	MOVD	R0, R6
 	MOVD	R0, R7
 	MOVD	R0, R8
 	MOVD	trap+0(FP), R9	// syscall entry
 	SYSCALL R9
 	MOVD	R3, r1+32(FP)
 	MOVD	R4, r2+40(FP)
 	RET
--- a/vendor/golang.org/x/sys/unix/asm_linux_riscv64.s
+++ b/vendor/golang.org/x/sys/unix/asm_linux_riscv64.s
@ -0,0 +1,49 @@
 // Copyright 2019 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build riscv64 && gc
 // +build riscv64
 // +build gc
 #include "textflag.h"
 //
 // System calls for linux/riscv64.
 //
 // Where available, just jump to package syscall's implementation of
 // these functions.
 TEXT ·Syscall(SB),NOSPLIT,$0-56
 	JMP	syscall·Syscall(SB)
 TEXT ·Syscall6(SB),NOSPLIT,$0-80
 	JMP	syscall·Syscall6(SB)
 TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
 	CALL	runtime·entersyscall(SB)
 	MOV	a1+8(FP), A0
 	MOV	a2+16(FP), A1
 	MOV	a3+24(FP), A2
 	MOV	trap+0(FP), A7	// syscall entry
 	ECALL
 	MOV	A0, r1+32(FP)	// r1
 	MOV	A1, r2+40(FP)	// r2
 	CALL	runtime·exitsyscall(SB)
 	RET
 TEXT ·RawSyscall(SB),NOSPLIT,$0-56
 	JMP	syscall·RawSyscall(SB)
 TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
 	JMP	syscall·RawSyscall6(SB)
 TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
 	MOV	a1+8(FP), A0
 	MOV	a2+16(FP), A1
 	MOV	a3+24(FP), A2
 	MOV	trap+0(FP), A7	// syscall entry
 	ECALL
 	MOV	A0, r1+32(FP)
 	MOV	A1, r2+40(FP)
 	RET
--- a/vendor/golang.org/x/sys/unix/asm_linux_s390x.s
+++ b/vendor/golang.org/x/sys/unix/asm_linux_s390x.s
@ -0,0 +1,57 @@
 // Copyright 2016 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build linux && s390x && gc
 // +build linux
 // +build s390x
 // +build gc
 #include "textflag.h"
 //
 // System calls for s390x, Linux
 //
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT ·Syscall(SB),NOSPLIT,$0-56
 	BR	syscall·Syscall(SB)
 TEXT ·Syscall6(SB),NOSPLIT,$0-80
 	BR	syscall·Syscall6(SB)
 TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
 	BL	runtime·entersyscall(SB)
 	MOVD	a1+8(FP), R2
 	MOVD	a2+16(FP), R3
 	MOVD	a3+24(FP), R4
 	MOVD	$0, R5
 	MOVD	$0, R6
 	MOVD	$0, R7
 	MOVD	trap+0(FP), R1	// syscall entry
 	SYSCALL
 	MOVD	R2, r1+32(FP)
 	MOVD	R3, r2+40(FP)
 	BL	runtime·exitsyscall(SB)
 	RET
 TEXT ·RawSyscall(SB),NOSPLIT,$0-56
 	BR	syscall·RawSyscall(SB)
 TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
 	BR	syscall·RawSyscall6(SB)
 TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
 	MOVD	a1+8(FP), R2
 	MOVD	a2+16(FP), R3
 	MOVD	a3+24(FP), R4
 	MOVD	$0, R5
 	MOVD	$0, R6
 	MOVD	$0, R7
 	MOVD	trap+0(FP), R1	// syscall entry
 	SYSCALL
 	MOVD	R2, r1+32(FP)
 	MOVD	R3, r2+40(FP)
 	RET
--- a/vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s
+++ b/vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s
@ -0,0 +1,30 @@
 // Copyright 2019 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build gc
 // +build gc
 #include "textflag.h"
 //
 // System call support for mips64, OpenBSD
 //
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 TEXT	·Syscall(SB),NOSPLIT,$0-56
 	JMP	syscall·Syscall(SB)
 TEXT	·Syscall6(SB),NOSPLIT,$0-80
 	JMP	syscall·Syscall6(SB)
 TEXT	·Syscall9(SB),NOSPLIT,$0-104
 	JMP	syscall·Syscall9(SB)
 TEXT	·RawSyscall(SB),NOSPLIT,$0-56
 	JMP	syscall·RawSyscall(SB)
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
 	JMP	syscall·RawSyscall6(SB)
--- a/vendor/golang.org/x/sys/unix/asm_solaris_amd64.s
+++ b/vendor/golang.org/x/sys/unix/asm_solaris_amd64.s
@ -0,0 +1,18 @@
 // Copyright 2014 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build gc
 // +build gc
 #include "textflag.h"
 //
 // System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go
 //
 TEXT ·sysvicall6(SB),NOSPLIT,$0-88
 	JMP	syscall·sysvicall6(SB)
 TEXT ·rawSysvicall6(SB),NOSPLIT,$0-88
 	JMP	syscall·rawSysvicall6(SB)
--- a/vendor/golang.org/x/sys/unix/asm_zos_s390x.s
+++ b/vendor/golang.org/x/sys/unix/asm_zos_s390x.s
@ -0,0 +1,426 @@
 // Copyright 2020 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build zos && s390x && gc
 // +build zos
 // +build s390x
 // +build gc
 #include "textflag.h"
 #define PSALAA            1208(R0)
 #define GTAB64(x)           80(x)
 #define LCA64(x)            88(x)
 #define CAA(x)               8(x)
 #define EDCHPXV(x)        1016(x)       // in the CAA
 #define SAVSTACK_ASYNC(x)  336(x)       // in the LCA
 // SS_*, where x=SAVSTACK_ASYNC
 #define SS_LE(x)             0(x)
 #define SS_GO(x)             8(x)
 #define SS_ERRNO(x)         16(x)
 #define SS_ERRNOJR(x)       20(x)
 #define LE_CALL BYTE $0x0D; BYTE $0x76; // BL R7, R6
 TEXT ·clearErrno(SB),NOSPLIT,$0-0
 	BL	addrerrno<>(SB)
 	MOVD	$0, 0(R3)
 	RET
 // Returns the address of errno in R3.
 TEXT addrerrno<>(SB),NOSPLIT|NOFRAME,$0-0
 	// Get library control area (LCA).
 	MOVW	PSALAA, R8
 	MOVD	LCA64(R8), R8
 	// Get __errno FuncDesc.
 	MOVD	CAA(R8), R9
 	MOVD	EDCHPXV(R9), R9
 	ADD	$(0x156*16), R9
 	LMG	0(R9), R5, R6
 	// Switch to saved LE stack.
 	MOVD	SAVSTACK_ASYNC(R8), R9
 	MOVD	0(R9), R4
 	MOVD	$0, 0(R9)
 	// Call __errno function.
 	LE_CALL
 	NOPH
 	// Switch back to Go stack.
 	XOR	R0, R0      // Restore R0 to $0.
 	MOVD	R4, 0(R9)   // Save stack pointer.
 	RET
 TEXT ·syscall_syscall(SB),NOSPLIT,$0-56
 	BL	runtime·entersyscall(SB)
 	MOVD	a1+8(FP), R1
 	MOVD	a2+16(FP), R2
 	MOVD	a3+24(FP), R3
 	// Get library control area (LCA).
 	MOVW	PSALAA, R8
 	MOVD	LCA64(R8), R8
 	// Get function.
 	MOVD	CAA(R8), R9
 	MOVD	EDCHPXV(R9), R9
 	MOVD	trap+0(FP), R5
 	SLD	$4, R5
 	ADD	R5, R9
 	LMG	0(R9), R5, R6
 	// Restore LE stack.
 	MOVD	SAVSTACK_ASYNC(R8), R9
 	MOVD	0(R9), R4
 	MOVD	$0, 0(R9)
 	// Call function.
 	LE_CALL
 	NOPH
 	XOR	R0, R0      // Restore R0 to $0.
 	MOVD	R4, 0(R9)   // Save stack pointer.
 	MOVD	R3, r1+32(FP)
 	MOVD	R0, r2+40(FP)
 	MOVD	R0, err+48(FP)
 	MOVW	R3, R4
 	CMP	R4, $-1
 	BNE	done
 	BL	addrerrno<>(SB)
 	MOVWZ	0(R3), R3
 	MOVD	R3, err+48(FP)
 done:
 	BL	runtime·exitsyscall(SB)
 	RET
 TEXT ·syscall_rawsyscall(SB),NOSPLIT,$0-56
 	MOVD	a1+8(FP), R1
 	MOVD	a2+16(FP), R2
 	MOVD	a3+24(FP), R3
 	// Get library control area (LCA).
 	MOVW	PSALAA, R8
 	MOVD	LCA64(R8), R8
 	// Get function.
 	MOVD	CAA(R8), R9
 	MOVD	EDCHPXV(R9), R9
 	MOVD	trap+0(FP), R5
 	SLD	$4, R5
 	ADD	R5, R9
 	LMG	0(R9), R5, R6
 	// Restore LE stack.
 	MOVD	SAVSTACK_ASYNC(R8), R9
 	MOVD	0(R9), R4
 	MOVD	$0, 0(R9)
 	// Call function.
 	LE_CALL
 	NOPH
 	XOR	R0, R0      // Restore R0 to $0.
 	MOVD	R4, 0(R9)   // Save stack pointer.
 	MOVD	R3, r1+32(FP)
 	MOVD	R0, r2+40(FP)
 	MOVD	R0, err+48(FP)
 	MOVW	R3, R4
 	CMP	R4, $-1
 	BNE	done
 	BL	addrerrno<>(SB)
 	MOVWZ	0(R3), R3
 	MOVD	R3, err+48(FP)
 done:
 	RET
 TEXT ·syscall_syscall6(SB),NOSPLIT,$0-80
 	BL	runtime·entersyscall(SB)
 	MOVD	a1+8(FP), R1
 	MOVD	a2+16(FP), R2
 	MOVD	a3+24(FP), R3
 	// Get library control area (LCA).
 	MOVW	PSALAA, R8
 	MOVD	LCA64(R8), R8
 	// Get function.
 	MOVD	CAA(R8), R9
 	MOVD	EDCHPXV(R9), R9
 	MOVD	trap+0(FP), R5
 	SLD	$4, R5
 	ADD	R5, R9
 	LMG	0(R9), R5, R6
 	// Restore LE stack.
 	MOVD	SAVSTACK_ASYNC(R8), R9
 	MOVD	0(R9), R4
 	MOVD	$0, 0(R9)
 	// Fill in parameter list.
 	MOVD	a4+32(FP), R12
 	MOVD	R12, (2176+24)(R4)
 	MOVD	a5+40(FP), R12
 	MOVD	R12, (2176+32)(R4)
 	MOVD	a6+48(FP), R12
 	MOVD	R12, (2176+40)(R4)
 	// Call function.
 	LE_CALL
 	NOPH
 	XOR	R0, R0      // Restore R0 to $0.
 	MOVD	R4, 0(R9)   // Save stack pointer.
 	MOVD	R3, r1+56(FP)
 	MOVD	R0, r2+64(FP)
 	MOVD	R0, err+72(FP)
 	MOVW	R3, R4
 	CMP	R4, $-1
 	BNE	done
 	BL	addrerrno<>(SB)
 	MOVWZ	0(R3), R3
 	MOVD	R3, err+72(FP)
 done:
 	BL	runtime·exitsyscall(SB)
 	RET
 TEXT ·syscall_rawsyscall6(SB),NOSPLIT,$0-80
 	MOVD	a1+8(FP), R1
 	MOVD	a2+16(FP), R2
 	MOVD	a3+24(FP), R3
 	// Get library control area (LCA).
 	MOVW	PSALAA, R8
 	MOVD	LCA64(R8), R8
 	// Get function.
 	MOVD	CAA(R8), R9
 	MOVD	EDCHPXV(R9), R9
 	MOVD	trap+0(FP), R5
 	SLD	$4, R5
 	ADD	R5, R9
 	LMG	0(R9), R5, R6
 	// Restore LE stack.
 	MOVD	SAVSTACK_ASYNC(R8), R9
 	MOVD	0(R9), R4
 	MOVD	$0, 0(R9)
 	// Fill in parameter list.
 	MOVD	a4+32(FP), R12
 	MOVD	R12, (2176+24)(R4)
 	MOVD	a5+40(FP), R12
 	MOVD	R12, (2176+32)(R4)
 	MOVD	a6+48(FP), R12
 	MOVD	R12, (2176+40)(R4)
 	// Call function.
 	LE_CALL
 	NOPH
 	XOR	R0, R0      // Restore R0 to $0.
 	MOVD	R4, 0(R9)   // Save stack pointer.
 	MOVD	R3, r1+56(FP)
 	MOVD	R0, r2+64(FP)
 	MOVD	R0, err+72(FP)
 	MOVW	R3, R4
 	CMP	R4, $-1
 	BNE	done
 	BL	·rrno<>(SB)
 	MOVWZ	0(R3), R3
 	MOVD	R3, err+72(FP)
 done:
 	RET
 TEXT ·syscall_syscall9(SB),NOSPLIT,$0
 	BL	runtime·entersyscall(SB)
 	MOVD	a1+8(FP), R1
 	MOVD	a2+16(FP), R2
 	MOVD	a3+24(FP), R3
 	// Get library control area (LCA).
 	MOVW	PSALAA, R8
 	MOVD	LCA64(R8), R8
 	// Get function.
 	MOVD	CAA(R8), R9
 	MOVD	EDCHPXV(R9), R9
 	MOVD	trap+0(FP), R5
 	SLD	$4, R5
 	ADD	R5, R9
 	LMG	0(R9), R5, R6
 	// Restore LE stack.
 	MOVD	SAVSTACK_ASYNC(R8), R9
 	MOVD	0(R9), R4
 	MOVD	$0, 0(R9)
 	// Fill in parameter list.
 	MOVD	a4+32(FP), R12
 	MOVD	R12, (2176+24)(R4)
 	MOVD	a5+40(FP), R12
 	MOVD	R12, (2176+32)(R4)
 	MOVD	a6+48(FP), R12
 	MOVD	R12, (2176+40)(R4)
 	MOVD	a7+56(FP), R12
 	MOVD	R12, (2176+48)(R4)
 	MOVD	a8+64(FP), R12
 	MOVD	R12, (2176+56)(R4)
 	MOVD	a9+72(FP), R12
 	MOVD	R12, (2176+64)(R4)
 	// Call function.
 	LE_CALL
 	NOPH
 	XOR	R0, R0      // Restore R0 to $0.
 	MOVD	R4, 0(R9)   // Save stack pointer.
 	MOVD	R3, r1+80(FP)
 	MOVD	R0, r2+88(FP)
 	MOVD	R0, err+96(FP)
 	MOVW	R3, R4
 	CMP	R4, $-1
 	BNE	done
 	BL	addrerrno<>(SB)
 	MOVWZ	0(R3), R3
 	MOVD	R3, err+96(FP)
 done:
        BL	runtime·exitsyscall(SB)
        RET
 TEXT ·syscall_rawsyscall9(SB),NOSPLIT,$0
 	MOVD	a1+8(FP), R1
 	MOVD	a2+16(FP), R2
 	MOVD	a3+24(FP), R3
 	// Get library control area (LCA).
 	MOVW	PSALAA, R8
 	MOVD	LCA64(R8), R8
 	// Get function.
 	MOVD	CAA(R8), R9
 	MOVD	EDCHPXV(R9), R9
 	MOVD	trap+0(FP), R5
 	SLD	$4, R5
 	ADD	R5, R9
 	LMG	0(R9), R5, R6
 	// Restore LE stack.
 	MOVD	SAVSTACK_ASYNC(R8), R9
 	MOVD	0(R9), R4
 	MOVD	$0, 0(R9)
 	// Fill in parameter list.
 	MOVD	a4+32(FP), R12
 	MOVD	R12, (2176+24)(R4)
 	MOVD	a5+40(FP), R12
 	MOVD	R12, (2176+32)(R4)
 	MOVD	a6+48(FP), R12
 	MOVD	R12, (2176+40)(R4)
 	MOVD	a7+56(FP), R12
 	MOVD	R12, (2176+48)(R4)
 	MOVD	a8+64(FP), R12
 	MOVD	R12, (2176+56)(R4)
 	MOVD	a9+72(FP), R12
 	MOVD	R12, (2176+64)(R4)
 	// Call function.
 	LE_CALL
 	NOPH
 	XOR	R0, R0      // Restore R0 to $0.
 	MOVD	R4, 0(R9)   // Save stack pointer.
 	MOVD	R3, r1+80(FP)
 	MOVD	R0, r2+88(FP)
 	MOVD	R0, err+96(FP)
 	MOVW	R3, R4
 	CMP	R4, $-1
 	BNE	done
 	BL	addrerrno<>(SB)
 	MOVWZ	0(R3), R3
 	MOVD	R3, err+96(FP)
 done:
 	RET
 // func svcCall(fnptr unsafe.Pointer, argv *unsafe.Pointer, dsa *uint64)
 TEXT ·svcCall(SB),NOSPLIT,$0
 	BL	runtime·save_g(SB)   // Save g and stack pointer
 	MOVW	PSALAA, R8
 	MOVD	LCA64(R8), R8
 	MOVD	SAVSTACK_ASYNC(R8), R9
 	MOVD	R15, 0(R9)
 	MOVD	argv+8(FP), R1       // Move function arguments into registers
 	MOVD	dsa+16(FP), g
 	MOVD	fnptr+0(FP), R15
 	BYTE	$0x0D                // Branch to function
 	BYTE	$0xEF
 	BL	runtime·load_g(SB)   // Restore g and stack pointer
 	MOVW	PSALAA, R8
 	MOVD	LCA64(R8), R8
 	MOVD	SAVSTACK_ASYNC(R8), R9
 	MOVD	0(R9), R15
 	RET
 // func svcLoad(name *byte) unsafe.Pointer
 TEXT ·svcLoad(SB),NOSPLIT,$0
 	MOVD	R15, R2          // Save go stack pointer
 	MOVD	name+0(FP), R0   // Move SVC args into registers
 	MOVD	$0x80000000, R1
 	MOVD	$0, R15
 	BYTE	$0x0A            // SVC 08 LOAD
 	BYTE	$0x08
 	MOVW	R15, R3          // Save return code from SVC
 	MOVD	R2, R15          // Restore go stack pointer
 	CMP	R3, $0           // Check SVC return code
 	BNE	error
 	MOVD	$-2, R3          // Reset last bit of entry point to zero
 	AND	R0, R3
 	MOVD	R3, addr+8(FP)   // Return entry point returned by SVC
 	CMP	R0, R3           // Check if last bit of entry point was set
 	BNE	done
 	MOVD	R15, R2          // Save go stack pointer
 	MOVD	$0, R15          // Move SVC args into registers (entry point still in r0 from SVC 08)
 	BYTE	$0x0A            // SVC 09 DELETE
 	BYTE	$0x09
 	MOVD	R2, R15          // Restore go stack pointer
 error:
 	MOVD	$0, addr+8(FP)   // Return 0 on failure
 done:
 	XOR	R0, R0           // Reset r0 to 0
 	RET
 // func svcUnload(name *byte, fnptr unsafe.Pointer) int64
 TEXT ·svcUnload(SB),NOSPLIT,$0
 	MOVD	R15, R2          // Save go stack pointer
 	MOVD	name+0(FP), R0   // Move SVC args into registers
 	MOVD	addr+8(FP), R15
 	BYTE	$0x0A            // SVC 09
 	BYTE	$0x09
 	XOR	R0, R0           // Reset r0 to 0
 	MOVD	R15, R1          // Save SVC return code
 	MOVD	R2, R15          // Restore go stack pointer
 	MOVD	R1, rc+0(FP)     // Return SVC return code
 	RET
 // func gettid() uint64
 TEXT ·gettid(SB), NOSPLIT, $0
 	// Get library control area (LCA).
 	MOVW PSALAA, R8
 	MOVD LCA64(R8), R8
 	// Get CEECAATHDID
 	MOVD CAA(R8), R9
 	MOVD 0x3D0(R9), R9
 	MOVD R9, ret+0(FP)
 	RET
--- a/vendor/golang.org/x/sys/unix/bluetooth_linux.go
+++ b/vendor/golang.org/x/sys/unix/bluetooth_linux.go
@ -0,0 +1,36 @@
 // Copyright 2016 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // Bluetooth sockets and messages
 package unix
 // Bluetooth Protocols
 const (
 	BTPROTO_L2CAP  = 0
 	BTPROTO_HCI    = 1
 	BTPROTO_SCO    = 2
 	BTPROTO_RFCOMM = 3
 	BTPROTO_BNEP   = 4
 	BTPROTO_CMTP   = 5
 	BTPROTO_HIDP   = 6
 	BTPROTO_AVDTP  = 7
 )
 const (
 	HCI_CHANNEL_RAW     = 0
 	HCI_CHANNEL_USER    = 1
 	HCI_CHANNEL_MONITOR = 2
 	HCI_CHANNEL_CONTROL = 3
 	HCI_CHANNEL_LOGGING = 4
 )
 // Socketoption Level
 const (
 	SOL_BLUETOOTH = 0x112
 	SOL_HCI       = 0x0
 	SOL_L2CAP     = 0x6
 	SOL_RFCOMM    = 0x12
 	SOL_SCO       = 0x11
 )
--- a/vendor/golang.org/x/sys/unix/cap_freebsd.go
+++ b/vendor/golang.org/x/sys/unix/cap_freebsd.go
@ -0,0 +1,196 @@
 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build freebsd
 // +build freebsd
 package unix
 import (
 	"errors"
 	"fmt"
 )
 // Go implementation of C mostly found in /usr/src/sys/kern/subr_capability.c
 const (
 	// This is the version of CapRights this package understands. See C implementation for parallels.
 	capRightsGoVersion = CAP_RIGHTS_VERSION_00
 	capArSizeMin       = CAP_RIGHTS_VERSION_00 + 2
 	capArSizeMax       = capRightsGoVersion + 2
 )
 var (
 	bit2idx = []int{
 		-1, 0, 1, -1, 2, -1, -1, -1, 3, -1, -1, -1, -1, -1, -1, -1,
 		4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 	}
 )
 func capidxbit(right uint64) int {
 	return int((right >> 57) & 0x1f)
 }
 func rightToIndex(right uint64) (int, error) {
 	idx := capidxbit(right)
 	if idx < 0 || idx >= len(bit2idx) {
 		return -2, fmt.Errorf("index for right 0x%x out of range", right)
 	}
 	return bit2idx[idx], nil
 }
 func caprver(right uint64) int {
 	return int(right >> 62)
 }
 func capver(rights *CapRights) int {
 	return caprver(rights.Rights[0])
 }
 func caparsize(rights *CapRights) int {
 	return capver(rights) + 2
 }
 // CapRightsSet sets the permissions in setrights in rights.
 func CapRightsSet(rights *CapRights, setrights []uint64) error {
 	// This is essentially a copy of cap_rights_vset()
 	if capver(rights) != CAP_RIGHTS_VERSION_00 {
 		return fmt.Errorf("bad rights version %d", capver(rights))
 	}
 	n := caparsize(rights)
 	if n < capArSizeMin || n > capArSizeMax {
 		return errors.New("bad rights size")
 	}
 	for _, right := range setrights {
 		if caprver(right) != CAP_RIGHTS_VERSION_00 {
 			return errors.New("bad right version")
 		}
 		i, err := rightToIndex(right)
 		if err != nil {
 			return err
 		}
 		if i >= n {
 			return errors.New("index overflow")
 		}
 		if capidxbit(rights.Rights[i]) != capidxbit(right) {
 			return errors.New("index mismatch")
 		}
 		rights.Rights[i] |= right
 		if capidxbit(rights.Rights[i]) != capidxbit(right) {
 			return errors.New("index mismatch (after assign)")
 		}
 	}
 	return nil
 }
 // CapRightsClear clears the permissions in clearrights from rights.
 func CapRightsClear(rights *CapRights, clearrights []uint64) error {
 	// This is essentially a copy of cap_rights_vclear()
 	if capver(rights) != CAP_RIGHTS_VERSION_00 {
 		return fmt.Errorf("bad rights version %d", capver(rights))
 	}
 	n := caparsize(rights)
 	if n < capArSizeMin || n > capArSizeMax {
 		return errors.New("bad rights size")
 	}
 	for _, right := range clearrights {
 		if caprver(right) != CAP_RIGHTS_VERSION_00 {
 			return errors.New("bad right version")
 		}
 		i, err := rightToIndex(right)
 		if err != nil {
 			return err
 		}
 		if i >= n {
 			return errors.New("index overflow")
 		}
 		if capidxbit(rights.Rights[i]) != capidxbit(right) {
 			return errors.New("index mismatch")
 		}
 		rights.Rights[i] &= ^(right & 0x01FFFFFFFFFFFFFF)
 		if capidxbit(rights.Rights[i]) != capidxbit(right) {
 			return errors.New("index mismatch (after assign)")
 		}
 	}
 	return nil
 }
 // CapRightsIsSet checks whether all the permissions in setrights are present in rights.
 func CapRightsIsSet(rights *CapRights, setrights []uint64) (bool, error) {
 	// This is essentially a copy of cap_rights_is_vset()
 	if capver(rights) != CAP_RIGHTS_VERSION_00 {
 		return false, fmt.Errorf("bad rights version %d", capver(rights))
 	}
 	n := caparsize(rights)
 	if n < capArSizeMin || n > capArSizeMax {
 		return false, errors.New("bad rights size")
 	}
 	for _, right := range setrights {
 		if caprver(right) != CAP_RIGHTS_VERSION_00 {
 			return false, errors.New("bad right version")
 		}
 		i, err := rightToIndex(right)
 		if err != nil {
 			return false, err
 		}
 		if i >= n {
 			return false, errors.New("index overflow")
 		}
 		if capidxbit(rights.Rights[i]) != capidxbit(right) {
 			return false, errors.New("index mismatch")
 		}
 		if (rights.Rights[i] & right) != right {
 			return false, nil
 		}
 	}
 	return true, nil
 }
 func capright(idx uint64, bit uint64) uint64 {
 	return ((1 << (57 + idx)) | bit)
 }
 // CapRightsInit returns a pointer to an initialised CapRights structure filled with rights.
 // See man cap_rights_init(3) and rights(4).
 func CapRightsInit(rights []uint64) (*CapRights, error) {
 	var r CapRights
 	r.Rights[0] = (capRightsGoVersion << 62) | capright(0, 0)
 	r.Rights[1] = capright(1, 0)
 	err := CapRightsSet(&r, rights)
 	if err != nil {
 		return nil, err
 	}
 	return &r, nil
 }
 // CapRightsLimit reduces the operations permitted on fd to at most those contained in rights.
 // The capability rights on fd can never be increased by CapRightsLimit.
 // See man cap_rights_limit(2) and rights(4).
 func CapRightsLimit(fd uintptr, rights *CapRights) error {
 	return capRightsLimit(int(fd), rights)
 }
 // CapRightsGet returns a CapRights structure containing the operations permitted on fd.
 // See man cap_rights_get(3) and rights(4).
 func CapRightsGet(fd uintptr) (*CapRights, error) {
 	r, err := CapRightsInit(nil)
 	if err != nil {
 		return nil, err
 	}
 	err = capRightsGet(capRightsGoVersion, int(fd), r)
 	if err != nil {
 		return nil, err
 	}
 	return r, nil
 }
--- a/vendor/golang.org/x/sys/unix/constants.go
+++ b/vendor/golang.org/x/sys/unix/constants.go
@ -0,0 +1,14 @@
 // Copyright 2015 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos
 package unix
 const (
 	R_OK = 0x4
 	W_OK = 0x2
 	X_OK = 0x1
 )
--- a/vendor/golang.org/x/sys/unix/dev_aix_ppc.go
+++ b/vendor/golang.org/x/sys/unix/dev_aix_ppc.go
@ -0,0 +1,27 @@
 // Copyright 2018 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build aix && ppc
 // +build aix,ppc
 // Functions to access/create device major and minor numbers matching the
 // encoding used by AIX.
 package unix
 // Major returns the major component of a Linux device number.
 func Major(dev uint64) uint32 {
 	return uint32((dev >> 16) & 0xffff)
 }
 // Minor returns the minor component of a Linux device number.
 func Minor(dev uint64) uint32 {
 	return uint32(dev & 0xffff)
 }
 // Mkdev returns a Linux device number generated from the given major and minor
 // components.
 func Mkdev(major, minor uint32) uint64 {
 	return uint64(((major) << 16) | (minor))
 }
--- a/vendor/golang.org/x/sys/unix/dev_aix_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/dev_aix_ppc64.go
@ -0,0 +1,29 @@
 // Copyright 2018 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //go:build aix && ppc64
 // +build aix,ppc64
 // Functions to access/create device major and minor numbers matching the
 // encoding used AIX.
 package unix
 // Major returns the major component of a Linux device number.
 func Major(dev uint64) uint32 {
 	return uint32((dev & 0x3fffffff00000000) >> 32)
 }
 // Minor returns the minor component of a Linux device number.
 func Minor(dev uint64) uint32 {
 	return uint32((dev & 0x00000000ffffffff) >> 0)
 }
 // Mkdev returns a Linux device number generated from the given major and minor
 // components.
 func Mkdev(major, minor uint32) uint64 {
 	var DEVNO64 uint64
 	DEVNO64 = 0x8000000000000000
 	return ((uint64(major) << 32) | (uint64(minor) & 0x00000000FFFFFFFF) | DEVNO64)
 }
--- a/vendor/golang.org/x/sys/unix/dev_darwin.go
+++ b/vendor/golang.org/x/sys/unix/dev_darwin.go
@ -0,0 +1,24 @@
 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // Functions to access/create device major and minor numbers matching the
 // encoding used in Darwin's sys/types.h header.
 package unix
 // Major returns the major component of a Darwin device number.
 func Major(dev uint64) uint32 {
 	return uint32((dev >> 24) & 0xff)
 }
 // Minor returns the minor component of a Darwin device number.
 func Minor(dev uint64) uint32 {
 	return uint32(dev & 0xffffff)
 }
 // Mkdev returns a Darwin device number generated from the given major and minor
 // components.
 func Mkdev(major, minor uint32) uint64 {
 	return (uint64(major) << 24) | uint64(minor)
 }
--- a/vendor/golang.org/x/sys/unix/dev_dragonfly.go
+++ b/vendor/golang.org/x/sys/unix/dev_dragonfly.go
@ -0,0 +1,30 @@
 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // Functions to access/create device major and minor numbers matching the
 // encoding used in Dragonfly's sys/types.h header.
 //
 // The information below is extracted and adapted from sys/types.h:
 //
 // Minor gives a cookie instead of an index since in order to avoid changing the
 // meanings of bits 0-15 or wasting time and space shifting bits 16-31 for
 // devices that don't use them.
 package unix
 // Major returns the major component of a DragonFlyBSD device number.
 func Major(dev uint64) uint32 {
 	return uint32((dev >> 8) & 0xff)
 }
 // Minor returns the minor component of a DragonFlyBSD device number.
 func Minor(dev uint64) uint32 {
 	return uint32(dev & 0xffff00ff)
 }
 // Mkdev returns a DragonFlyBSD device number generated from the given major and
 // minor components.
 func Mkdev(major, minor uint32) uint64 {
 	return (uint64(major) << 8) | uint64(minor)
 }
--- a/vendor/golang.org/x/sys/unix/dev_freebsd.go
+++ b/vendor/golang.org/x/sys/unix/dev_freebsd.go
@ -0,0 +1,30 @@
 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // Functions to access/create device major and minor numbers matching the
 // encoding used in FreeBSD's sys/types.h header.
 //
 // The information below is extracted and adapted from sys/types.h:
 //
 // Minor gives a cookie instead of an index since in order to avoid changing the
 // meanings of bits 0-15 or wasting time and space shifting bits 16-31 for
 // devices that don't use them.
 package unix
 // Major returns the major component of a FreeBSD device number.
 func Major(dev uint64) uint32 {
 	return uint32((dev >> 8) & 0xff)
 }
 // Minor returns the minor component of a FreeBSD device number.
 func Minor(dev uint64) uint32 {
 	return uint32(dev & 0xffff00ff)
 }
 // Mkdev returns a FreeBSD device number generated from the given major and
 // minor components.
 func Mkdev(major, minor uint32) uint64 {
 	return (uint64(major) << 8) | uint64(minor)
 }
--- a/vendor/golang.org/x/sys/unix/dev_linux.go
+++ b/vendor/golang.org/x/sys/unix/dev_linux.go
@ -0,0 +1,42 @@
 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // Functions to access/create device major and minor numbers matching the
 // encoding used by the Linux kernel and glibc.
 //
 // The information below is extracted and adapted from bits/sysmacros.h in the
 // glibc sources:
 //
 // dev_t in glibc is 64-bit, with 32-bit major and minor numbers. glibc's
 // default encoding is MMMM Mmmm mmmM MMmm, where M is a hex digit of the major
 // number and m is a hex digit of the minor number. This is backward compatible
 // with legacy systems where dev_t is 16 bits wide, encoded as MMmm. It is also
 // backward compatible with the Linux kernel, which for some architectures uses
 // 32-bit dev_t, encoded as mmmM MMmm.
 package unix
 // Major returns the major component of a Linux device number.
 func Major(dev uint64) uint32 {
 	major := uint32((dev & 0x00000000000fff00) >> 8)
 	major |= uint32((dev & 0xfffff00000000000) >> 32)
 	return major
 }
 // Minor returns the minor component of a Linux device number.
 func Minor(dev uint64) uint32 {
 	minor := uint32((dev & 0x00000000000000ff) >> 0)
 	minor |= uint32((dev & 0x00000ffffff00000) >> 12)
 	return minor
 }
 // Mkdev returns a Linux device number generated from the given major and minor
 // components.
 func Mkdev(major, minor uint32) uint64 {
 	dev := (uint64(major) & 0x00000fff) << 8
 	dev |= (uint64(major) & 0xfffff000) << 32
 	dev |= (uint64(minor) & 0x000000ff) << 0
 	dev |= (uint64(minor) & 0xffffff00) << 12
 	return dev
 }
--- a/vendor/golang.org/x/sys/unix/dev_netbsd.go
+++ b/vendor/golang.org/x/sys/unix/dev_netbsd.go
@ -0,0 +1,29 @@
 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // Functions to access/create device major and minor numbers matching the
 // encoding used in NetBSD's sys/types.h header.
 package unix
 // Major returns the major component of a NetBSD device number.
 func Major(dev uint64) uint32 {
 	return uint32((dev & 0x000fff00) >> 8)
 }
 // Minor returns the minor component of a NetBSD device number.
 func Minor(dev uint64) uint32 {
 	minor := uint32((dev & 0x000000ff) >> 0)
 	minor |= uint32((dev & 0xfff00000) >> 12)
 	return minor
 }
 // Mkdev returns a NetBSD device number generated from the given major and minor
 // components.
 func Mkdev(major, minor uint32) uint64 {
 	dev := (uint64(major) << 8) & 0x000fff00
 	dev |= (uint64(minor) << 12) & 0xfff00000
 	dev |= (uint64(minor) << 0) & 0x000000ff
 	return dev
 }
--- a/vendor/golang.org/x/sys/unix/dev_openbsd.go
+++ b/vendor/golang.org/x/sys/unix/dev_openbsd.go
@ -0,0 +1,29 @@
 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // Functions to access/create device major and minor numbers matching the
 // encoding used in OpenBSD's sys/types.h header.
 package unix
 // Major returns the major component of an OpenBSD device number.
 func Major(dev uint64) uint32 {
 	return uint32((dev & 0x0000ff00) >> 8)
 }
 // Minor returns the minor component of an OpenBSD device number.
 func Minor(dev uint64) uint32 {
 	minor := uint32((dev & 0x000000ff) >> 0)
 	minor |= uint32((dev & 0xffff0000) >> 8)
 	return minor
 }
 // Mkdev returns an OpenBSD device number generated from the given major and minor
 // components.
 func Mkdev(major, minor uint32) uint64 {
 	dev := (uint64(major) << 8) & 0x0000ff00
 	dev |= (uint64(minor) << 8) & 0xffff0000
 	dev |= (uint64(minor) << 0) & 0x000000ff
 	return dev
 }
--- a/Show More
+++ b/Show More
		`@ -0,0 +1,2 @@`
							`github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=`
							`github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=`