diff --git a/http2/h2demo/.gitignore b/http2/h2demo/.gitignore
deleted file mode 100644
index 8a1133f..0000000
--- a/http2/h2demo/.gitignore
+++ /dev/null
@@ -1,6 +0,0 @@
-h2demo
-h2demo.linux
-client-id.dat
-client-secret.dat
-token.dat
-ca-certificates.crt
diff --git a/http2/h2demo/Dockerfile b/http2/h2demo/Dockerfile
deleted file mode 100644
index 4ca65e4..0000000
--- a/http2/h2demo/Dockerfile
+++ /dev/null
@@ -1,36 +0,0 @@
-# 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.
-
-FROM golang:1.13 AS build
-LABEL maintainer "golang-dev@googlegroups.com"
-
-ENV GO111MODULE=on
-
-RUN mkdir /gocache
-ENV GOCACHE /gocache
-
-COPY go.mod /go/src/golang.org/x/build/go.mod
-COPY go.sum /go/src/golang.org/x/build/go.sum
-
-# Optimization for iterative docker build speed, not necessary for correctness:
-# TODO: write a tool to make writing Go module-friendly Dockerfiles easier.
-RUN go install cloud.google.com/go/storage
-RUN go install golang.org/x/build/autocertcache
-RUN go install go4.org/syncutil/singleflight
-RUN go install golang.org/x/crypto/acme/autocert
-
-COPY . /go/src/golang.org/x/net
-
-# Install binary to /go/bin:
-WORKDIR /go/src/golang.org/x/net/http2/h2demo
-RUN go install -tags "netgo"
-
-
-FROM debian:stretch
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    ca-certificates netbase \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY --from=build /go/bin/h2demo /h2demo
-
diff --git a/http2/h2demo/Makefile b/http2/h2demo/Makefile
deleted file mode 100644
index ceeb9bc..0000000
--- a/http2/h2demo/Makefile
+++ /dev/null
@@ -1,33 +0,0 @@
-# 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.
-
-MUTABLE_VERSION ?= latest
-VERSION ?= $(shell git rev-parse --short HEAD)
-IMAGE_NAME=h2demo
-
-docker: Dockerfile
-	go install golang.org/x/build/cmd/xb
-	xb docker build -t golang/$(IMAGE_NAME) -f Dockerfile ../..
-
-push-staging: docker
-	go install golang.org/x/build/cmd/xb
-	xb --staging docker tag golang/$(IMAGE_NAME) REPO/$(IMAGE_NAME):$(VERSION)
-	xb --staging docker tag golang/$(IMAGE_NAME) REPO/$(IMAGE_NAME):latest
-	xb --staging docker push REPO/$(IMAGE_NAME):$(VERSION)
-	xb --staging docker push REPO/$(IMAGE_NAME):latest
-
-push-prod: docker
-	go install golang.org/x/build/cmd/xb
-	xb --prod docker tag golang/$(IMAGE_NAME) REPO/$(IMAGE_NAME):$(VERSION)
-	xb --prod docker tag golang/$(IMAGE_NAME) REPO/$(IMAGE_NAME):latest
-	xb --prod docker push REPO/$(IMAGE_NAME):$(VERSION)
-	xb --prod docker push REPO/$(IMAGE_NAME):latest
-
-# TODO(bradfitz): add REPO subsitution in xb for the kubectl command.
-deploy-prod: push-prod
-	xb --prod kubectl --namespace prod set image deployment/h2demo-deployment h2demo=gcr.io/symbolic-datum-552/h2demo:$(VERSION)
-deploy-staging: push-staging
-	xb --staging kubectl set image deployment/h2demo-deployment h2demo=gcr.io/go-dashboard-dev/h2demo:$(VERSION)
-
-FORCE:
diff --git a/http2/h2demo/README b/http2/h2demo/README
deleted file mode 100644
index 9225403..0000000
--- a/http2/h2demo/README
+++ /dev/null
@@ -1,19 +0,0 @@
-This is a demo webserver that shows off Go's HTTP/2 support.
-
-It runs at https://http2.golang.org/ so people can hit our
-implementation with their HTTP/2 clients, etc. We intentionally do not
-run it behind any other HTTP implementation so clients (including
-people demonstrating attacks, etc) can hit our server directly. It
-just runs behind a TCP load balancer.
-
-When running locally, you'll need to click through TLS cert warnings.
-The dev cert was initially made like:
-
-Make CA:
-$ openssl genrsa -out rootCA.key 2048
-$ openssl req -x509 -new -nodes -key rootCA.key -days 1024 -out rootCA.pem
-
-Make cert:
-$ openssl genrsa -out server.key 2048
-$ openssl req -new -key server.key -out server.csr
-$ openssl x509 -req -in server.csr -CA rootCA.pem -CAkey rootCA.key -CAcreateserial -out server.crt -days 500
diff --git a/http2/h2demo/deployment-prod.yaml b/http2/h2demo/deployment-prod.yaml
deleted file mode 100644
index bc99f06..0000000
--- a/http2/h2demo/deployment-prod.yaml
+++ /dev/null
@@ -1,33 +0,0 @@
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  namespace: prod
-  name: h2demo-deployment
-spec:
-  selector:
-    matchLabels:
-      app: h2demo
-  replicas: 1
-  template:
-    metadata:
-      labels:
-        app: h2demo
-      annotations:
-        container.seccomp.security.alpha.kubernetes.io/h2demo: docker/default
-        container.apparmor.security.beta.kubernetes.io/h2demo: runtime/default
-    spec:
-      serviceAccountName: h2demo
-      containers:
-      - name: h2demo
-        image: gcr.io/symbolic-datum-552/h2demo:latest
-        imagePullPolicy: Always
-        command: ["/h2demo", "-prod"]
-        ports:
-        - containerPort: 80
-        - containerPort: 443
-        resources:
-          requests:
-            cpu: "1"
-            memory: "1Gi"
-          limits:
-            memory: "2Gi"
diff --git a/http2/h2demo/go.mod b/http2/h2demo/go.mod
deleted file mode 100644
index ba8e29f..0000000
--- a/http2/h2demo/go.mod
+++ /dev/null
@@ -1,13 +0,0 @@
-module golang.org/x/net/http2/h2demo
-
-go 1.12
-
-require (
-	cloud.google.com/go v0.38.0
-	go4.org v0.0.0-20190218023631-ce4c26f7be8e
-	golang.org/x/build v0.0.0-20190509182522-45de920fc22c
-	golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9
-	golang.org/x/net v0.0.0-20190502183928-7f726cade0ab
-)
-
-replace golang.org/x/net => ../..
diff --git a/http2/h2demo/go.sum b/http2/h2demo/go.sum
deleted file mode 100644
index 2506629..0000000
--- a/http2/h2demo/go.sum
+++ /dev/null
@@ -1,101 +0,0 @@
-cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.38.0 h1:ROfEUZz+Gh5pa62DJWXSaonyu3StP6EA6lPEXPI6mCo=
-cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
-github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g=
-github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/coreos/go-systemd v0.0.0-20181012123002-c6f51f82210d/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
-github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ=
-github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
-github.com/google/martian v2.1.0+incompatible h1:/CP5g8u/VJHijgedC/Legn3BAbAaWPgecwXBIDzw5no=
-github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
-github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/googleapis/gax-go/v2 v2.0.4 h1:hU4mGcQI4DaAYW+IbTun+2qEZVFxK0ySjQLTbS0VQKc=
-github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
-github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
-github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hashicorp/golang-lru v0.5.1 h1:0hERBMJE1eitiLkihrMvRVBYAkpHzc/J3QdDN+dAcgU=
-github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/jellevandenhooff/dkim v0.0.0-20150330215556-f50fe3d243e1/go.mod h1:E0B/fFc00Y+Rasa88328GlI/XbtyysCtTHZS8h7IrBU=
-github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
-github.com/kr/pty v1.1.3/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA=
-go.opencensus.io v0.21.0 h1:mU6zScU4U1YAFPHEHYk+3JC4SY7JxgkqS10ZOSyksNg=
-go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
-go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE=
-go4.org v0.0.0-20190218023631-ce4c26f7be8e h1:m9LfARr2VIOW0vsV19kEKp/sWQvZnGobA8JHui/XJoY=
-go4.org v0.0.0-20190218023631-ce4c26f7be8e/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE=
-golang.org/x/build v0.0.0-20190509182522-45de920fc22c h1:lgCiAYQNZHWRJOB1au5nVtnBZS1ZmKN1DpViRg23ZZc=
-golang.org/x/build v0.0.0-20190509182522-45de920fc22c/go.mod h1:fYw7AShPAhGMdXqA9gRadk/CcMsvLlClpE5oBwnS3dM=
-golang.org/x/crypto v0.0.0-20190424203555-c05e17bb3b2d/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-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-20190402181905-9f3314589c9a h1:tImsplftrFpALCYumobsd0K86vlAs/eXGFms2txfJfA=
-golang.org/x/oauth2 v0.0.0-20190402181905-9f3314589c9a/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/perf v0.0.0-20180704124530-6e6d33e29852/go.mod h1:JLpeXjPJfIyPr5TlbXLkXWLhP8nz10XfvxElABhCtcw=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190502175342-a43fa875dd82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da h1:b3NXsE2LusjYGGjL5bxEVZZORm/YEFFrWFjR8eFrw/c=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-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=
-golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-google.golang.org/api v0.4.0 h1:KKgc1aqhV8wDPbDzlDtpvyjZFY3vjz85FP7p4wcQUyI=
-google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
-google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
-google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.5.0 h1:KxkO13IPW4Lslp2bz+KHP2E3gtFlrIGNThxkZQ3g+4c=
-google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873 h1:nfPFGzJkUDX6uBmpN/pSw7MbOAWegH5QDQuoXFHedLg=
-google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.20.1 h1:Hz2g2wirWK7H0qIIhGIqRGTuMwTE8HEKFnDZZ7lm9NU=
-google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
-gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
-grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJdjuHRquDANNeA4x7B8WQ9o=
-honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
diff --git a/http2/h2demo/h2demo.go b/http2/h2demo/h2demo.go
deleted file mode 100644
index 8ac8d71..0000000
--- a/http2/h2demo/h2demo.go
+++ /dev/null
@@ -1,564 +0,0 @@
-// 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.
-
-package main
-
-import (
-	"bytes"
-	"context"
-	"crypto/tls"
-	"flag"
-	"fmt"
-	"hash/crc32"
-	"image"
-	"image/jpeg"
-	"io"
-	"io/ioutil"
-	"log"
-	"net"
-	"net/http"
-	"path"
-	"regexp"
-	"runtime"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"cloud.google.com/go/storage"
-	"go4.org/syncutil/singleflight"
-	"golang.org/x/build/autocertcache"
-	"golang.org/x/crypto/acme/autocert"
-	"golang.org/x/net/http2"
-)
-
-var (
-	prod = flag.Bool("prod", false, "Whether to configure itself to be the production http2.golang.org server.")
-
-	httpsAddr = flag.String("https_addr", "localhost:4430", "TLS address to listen on ('host:port' or ':port'). Required.")
-	httpAddr  = flag.String("http_addr", "", "Plain HTTP address to listen on ('host:port', or ':port'). Empty means no HTTP.")
-
-	hostHTTP  = flag.String("http_host", "", "Optional host or host:port to use for http:// links to this service. By default, this is implied from -http_addr.")
-	hostHTTPS = flag.String("https_host", "", "Optional host or host:port to use for http:// links to this service. By default, this is implied from -https_addr.")
-)
-
-func homeOldHTTP(w http.ResponseWriter, r *http.Request) {
-	if r.Host == "http1.golang.org" {
-		http.Redirect(w, r, "https://http2.golang.org/", http.StatusFound)
-		return
-	}
-	io.WriteString(w, `<html>
-<body>
-<h1>Go + HTTP/2</h1>
-<p>Welcome to <a href="https://golang.org/">the Go language</a>'s <a href="https://http2.github.io/">HTTP/2</a> demo & interop server.</p>
-<p>Unfortunately, you're <b>not</b> using HTTP/2 right now. To do so:</p>
-<ul>
-   <li>Use Firefox Nightly or go to <b>about:config</b> and enable "network.http.spdy.enabled.http2draft"</li>
-   <li>Use Google Chrome Canary and/or go to <b>chrome://flags/#enable-spdy4</b> to <i>Enable SPDY/4</i> (Chrome's name for HTTP/2)</li>
-</ul>
-<p>See code & instructions for connecting at <a href="https://github.com/golang/net/tree/master/http2">https://github.com/golang/net/tree/master/http2</a>.</p>
-
-</body></html>`)
-}
-
-func home(w http.ResponseWriter, r *http.Request) {
-	if r.URL.Path != "/" {
-		http.NotFound(w, r)
-		return
-	}
-	io.WriteString(w, `<html>
-<body>
-<h1>Go + HTTP/2</h1>
-
-<p>Welcome to <a href="https://golang.org/">the Go language</a>'s <a
-href="https://http2.github.io/">HTTP/2</a> demo & interop server.</p>
-
-<p>Congratulations, <b>you're using HTTP/2 right now</b>.</p>
-
-<p>This server exists for others in the HTTP/2 community to test their HTTP/2 client implementations and point out flaws in our server.</p>
-
-<p>
-The code is at <a href="https://golang.org/x/net/http2">golang.org/x/net/http2</a> and
-is used transparently by the Go standard library from Go 1.6 and later.
-</p>
-
-<p>Contact info: <i>bradfitz@golang.org</i>, or <a
-href="https://golang.org/s/http2bug">file a bug</a>.</p>
-
-<h2>Handlers for testing</h2>
-<ul>
-  <li>GET <a href="/reqinfo">/reqinfo</a> to dump the request + headers received</li>
-  <li>GET <a href="/clockstream">/clockstream</a> streams the current time every second</li>
-  <li>GET <a href="/gophertiles">/gophertiles</a> to see a page with a bunch of images</li>
-  <li>GET <a href="/serverpush">/serverpush</a> to see a page with server push</li>
-  <li>GET <a href="/file/gopher.png">/file/gopher.png</a> for a small file (does If-Modified-Since, Content-Range, etc)</li>
-  <li>GET <a href="/file/go.src.tar.gz">/file/go.src.tar.gz</a> for a larger file (~10 MB)</li>
-  <li>GET <a href="/redirect">/redirect</a> to redirect back to / (this page)</li>
-  <li>GET <a href="/goroutines">/goroutines</a> to see all active goroutines in this server</li>
-  <li>PUT something to <a href="/crc32">/crc32</a> to get a count of number of bytes and its CRC-32</li>
-  <li>PUT something to <a href="/ECHO">/ECHO</a> and it will be streamed back to you capitalized</li>
-</ul>
-
-</body></html>`)
-}
-
-func reqInfoHandler(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "text/plain")
-	fmt.Fprintf(w, "Method: %s\n", r.Method)
-	fmt.Fprintf(w, "Protocol: %s\n", r.Proto)
-	fmt.Fprintf(w, "Host: %s\n", r.Host)
-	fmt.Fprintf(w, "RemoteAddr: %s\n", r.RemoteAddr)
-	fmt.Fprintf(w, "RequestURI: %q\n", r.RequestURI)
-	fmt.Fprintf(w, "URL: %#v\n", r.URL)
-	fmt.Fprintf(w, "Body.ContentLength: %d (-1 means unknown)\n", r.ContentLength)
-	fmt.Fprintf(w, "Close: %v (relevant for HTTP/1 only)\n", r.Close)
-	fmt.Fprintf(w, "TLS: %#v\n", r.TLS)
-	fmt.Fprintf(w, "\nHeaders:\n")
-	r.Header.Write(w)
-}
-
-func crcHandler(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "PUT" {
-		http.Error(w, "PUT required.", 400)
-		return
-	}
-	crc := crc32.NewIEEE()
-	n, err := io.Copy(crc, r.Body)
-	if err == nil {
-		w.Header().Set("Content-Type", "text/plain")
-		fmt.Fprintf(w, "bytes=%d, CRC32=%x", n, crc.Sum(nil))
-	}
-}
-
-type capitalizeReader struct {
-	r io.Reader
-}
-
-func (cr capitalizeReader) Read(p []byte) (n int, err error) {
-	n, err = cr.r.Read(p)
-	for i, b := range p[:n] {
-		if b >= 'a' && b <= 'z' {
-			p[i] = b - ('a' - 'A')
-		}
-	}
-	return
-}
-
-type flushWriter struct {
-	w io.Writer
-}
-
-func (fw flushWriter) Write(p []byte) (n int, err error) {
-	n, err = fw.w.Write(p)
-	if f, ok := fw.w.(http.Flusher); ok {
-		f.Flush()
-	}
-	return
-}
-
-func echoCapitalHandler(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "PUT" {
-		http.Error(w, "PUT required.", 400)
-		return
-	}
-	if f, ok := w.(http.Flusher); ok {
-		f.Flush()
-	}
-	io.Copy(flushWriter{w}, capitalizeReader{r.Body})
-}
-
-var (
-	fsGrp   singleflight.Group
-	fsMu    sync.Mutex // guards fsCache
-	fsCache = map[string]http.Handler{}
-)
-
-// fileServer returns a file-serving handler that proxies URL.
-// It lazily fetches URL on the first access and caches its contents forever.
-func fileServer(url string, latency time.Duration) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if latency > 0 {
-			time.Sleep(latency)
-		}
-		hi, err := fsGrp.Do(url, func() (interface{}, error) {
-			fsMu.Lock()
-			if h, ok := fsCache[url]; ok {
-				fsMu.Unlock()
-				return h, nil
-			}
-			fsMu.Unlock()
-
-			res, err := http.Get(url)
-			if err != nil {
-				return nil, err
-			}
-			defer res.Body.Close()
-			slurp, err := ioutil.ReadAll(res.Body)
-			if err != nil {
-				return nil, err
-			}
-
-			modTime := time.Now()
-			var h http.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				http.ServeContent(w, r, path.Base(url), modTime, bytes.NewReader(slurp))
-			})
-			fsMu.Lock()
-			fsCache[url] = h
-			fsMu.Unlock()
-			return h, nil
-		})
-		if err != nil {
-			http.Error(w, err.Error(), 500)
-			return
-		}
-		hi.(http.Handler).ServeHTTP(w, r)
-	})
-}
-
-func clockStreamHandler(w http.ResponseWriter, r *http.Request) {
-	clientGone := w.(http.CloseNotifier).CloseNotify()
-	w.Header().Set("Content-Type", "text/plain")
-	ticker := time.NewTicker(1 * time.Second)
-	defer ticker.Stop()
-	fmt.Fprintf(w, "# ~1KB of junk to force browsers to start rendering immediately: \n")
-	io.WriteString(w, strings.Repeat("# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", 13))
-
-	for {
-		fmt.Fprintf(w, "%v\n", time.Now())
-		w.(http.Flusher).Flush()
-		select {
-		case <-ticker.C:
-		case <-clientGone:
-			log.Printf("Client %v disconnected from the clock", r.RemoteAddr)
-			return
-		}
-	}
-}
-
-func registerHandlers() {
-	tiles := newGopherTilesHandler()
-	push := newPushHandler()
-
-	mux2 := http.NewServeMux()
-	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/gophertiles":
-			tiles.ServeHTTP(w, r) // allow HTTP/2 + HTTP/1.x
-			return
-		case strings.HasPrefix(r.URL.Path, "/serverpush"):
-			push.ServeHTTP(w, r) // allow HTTP/2 + HTTP/1.x
-			return
-		case r.TLS == nil: // do not allow HTTP/1.x for anything else
-			http.Redirect(w, r, "https://"+httpsHost()+"/", http.StatusFound)
-			return
-		}
-		if r.ProtoMajor == 1 {
-			if r.URL.Path == "/reqinfo" {
-				reqInfoHandler(w, r)
-				return
-			}
-			homeOldHTTP(w, r)
-			return
-		}
-		mux2.ServeHTTP(w, r)
-	})
-	mux2.HandleFunc("/", home)
-	mux2.Handle("/file/gopher.png", fileServer("https://golang.org/doc/gopher/frontpage.png", 0))
-	mux2.Handle("/file/go.src.tar.gz", fileServer("https://storage.googleapis.com/golang/go1.4.1.src.tar.gz", 0))
-	mux2.HandleFunc("/reqinfo", reqInfoHandler)
-	mux2.HandleFunc("/crc32", crcHandler)
-	mux2.HandleFunc("/ECHO", echoCapitalHandler)
-	mux2.HandleFunc("/clockstream", clockStreamHandler)
-	mux2.Handle("/gophertiles", tiles)
-	mux2.HandleFunc("/redirect", func(w http.ResponseWriter, r *http.Request) {
-		http.Redirect(w, r, "/", http.StatusFound)
-	})
-	stripHomedir := regexp.MustCompile(`/(Users|home)/\w+`)
-	mux2.HandleFunc("/goroutines", func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
-		buf := make([]byte, 2<<20)
-		w.Write(stripHomedir.ReplaceAll(buf[:runtime.Stack(buf, true)], nil))
-	})
-}
-
-var pushResources = map[string]http.Handler{
-	"/serverpush/static/jquery.min.js": fileServer("https://ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js", 100*time.Millisecond),
-	"/serverpush/static/godocs.js":     fileServer("https://golang.org/lib/godoc/godocs.js", 100*time.Millisecond),
-	"/serverpush/static/playground.js": fileServer("https://golang.org/lib/godoc/playground.js", 100*time.Millisecond),
-	"/serverpush/static/style.css":     fileServer("https://golang.org/lib/godoc/style.css", 100*time.Millisecond),
-}
-
-func newPushHandler() http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		for path, handler := range pushResources {
-			if r.URL.Path == path {
-				handler.ServeHTTP(w, r)
-				return
-			}
-		}
-
-		cacheBust := time.Now().UnixNano()
-		if pusher, ok := w.(http.Pusher); ok {
-			for path := range pushResources {
-				url := fmt.Sprintf("%s?%d", path, cacheBust)
-				if err := pusher.Push(url, nil); err != nil {
-					log.Printf("Failed to push %v: %v", path, err)
-				}
-			}
-		}
-		time.Sleep(100 * time.Millisecond) // fake network latency + parsing time
-		if err := pushTmpl.Execute(w, struct {
-			CacheBust   int64
-			HTTPSHost   string
-			HTTP1Prefix string
-		}{
-			CacheBust:   cacheBust,
-			HTTPSHost:   httpsHost(),
-			HTTP1Prefix: http1Prefix(),
-		}); err != nil {
-			log.Printf("Executing server push template: %v", err)
-		}
-	})
-}
-
-func newGopherTilesHandler() http.Handler {
-	const gopherURL = "https://blog.golang.org/2years/2years-gophers.jpg"
-	res, err := http.Get(gopherURL)
-	if err != nil {
-		log.Fatal(err)
-	}
-	if res.StatusCode != 200 {
-		log.Fatalf("Error fetching %s: %v", gopherURL, res.Status)
-	}
-	slurp, err := ioutil.ReadAll(res.Body)
-	res.Body.Close()
-	if err != nil {
-		log.Fatal(err)
-	}
-	im, err := jpeg.Decode(bytes.NewReader(slurp))
-	if err != nil {
-		if len(slurp) > 1024 {
-			slurp = slurp[:1024]
-		}
-		log.Fatalf("Failed to decode gopher image: %v (got %q)", err, slurp)
-	}
-
-	type subImager interface {
-		SubImage(image.Rectangle) image.Image
-	}
-	const tileSize = 32
-	xt := im.Bounds().Max.X / tileSize
-	yt := im.Bounds().Max.Y / tileSize
-	var tile [][][]byte // y -> x -> jpeg bytes
-	for yi := 0; yi < yt; yi++ {
-		var row [][]byte
-		for xi := 0; xi < xt; xi++ {
-			si := im.(subImager).SubImage(image.Rectangle{
-				Min: image.Point{xi * tileSize, yi * tileSize},
-				Max: image.Point{(xi + 1) * tileSize, (yi + 1) * tileSize},
-			})
-			buf := new(bytes.Buffer)
-			if err := jpeg.Encode(buf, si, &jpeg.Options{Quality: 90}); err != nil {
-				log.Fatal(err)
-			}
-			row = append(row, buf.Bytes())
-		}
-		tile = append(tile, row)
-	}
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		ms, _ := strconv.Atoi(r.FormValue("latency"))
-		const nanosPerMilli = 1e6
-		if r.FormValue("x") != "" {
-			x, _ := strconv.Atoi(r.FormValue("x"))
-			y, _ := strconv.Atoi(r.FormValue("y"))
-			if ms <= 1000 {
-				time.Sleep(time.Duration(ms) * nanosPerMilli)
-			}
-			if x >= 0 && x < xt && y >= 0 && y < yt {
-				http.ServeContent(w, r, "", time.Time{}, bytes.NewReader(tile[y][x]))
-				return
-			}
-		}
-		io.WriteString(w, "<html><body onload='showtimes()'>")
-		fmt.Fprintf(w, "A grid of %d tiled images is below. Compare:<p>", xt*yt)
-		for _, ms := range []int{0, 30, 200, 1000} {
-			d := time.Duration(ms) * nanosPerMilli
-			fmt.Fprintf(w, "[<a href='https://%s/gophertiles?latency=%d'>HTTP/2, %v latency</a>] [<a href='%s/gophertiles?latency=%d'>HTTP/1, %v latency</a>]<br>\n",
-				httpsHost(), ms, d,
-				http1Prefix(), ms, d,
-			)
-		}
-		io.WriteString(w, "<p>\n")
-		cacheBust := time.Now().UnixNano()
-		for y := 0; y < yt; y++ {
-			for x := 0; x < xt; x++ {
-				fmt.Fprintf(w, "<img width=%d height=%d src='/gophertiles?x=%d&y=%d&cachebust=%d&latency=%d'>",
-					tileSize, tileSize, x, y, cacheBust, ms)
-			}
-			io.WriteString(w, "<br/>\n")
-		}
-		io.WriteString(w, `<p><div id='loadtimes'></div></p>
-<script>
-function showtimes() {
-	var times = 'Times from connection start:<br>'
-	times += 'DOM loaded: ' + (window.performance.timing.domContentLoadedEventEnd - window.performance.timing.connectStart) + 'ms<br>'
-	times += 'DOM complete (images loaded): ' + (window.performance.timing.domComplete - window.performance.timing.connectStart) + 'ms<br>'
-	document.getElementById('loadtimes').innerHTML = times
-}
-</script>
-<hr><a href='/'>&lt;&lt Back to Go HTTP/2 demo server</a></body></html>`)
-	})
-}
-
-func httpsHost() string {
-	if *hostHTTPS != "" {
-		return *hostHTTPS
-	}
-	if v := *httpsAddr; strings.HasPrefix(v, ":") {
-		return "localhost" + v
-	} else {
-		return v
-	}
-}
-
-func http1Prefix() string {
-	if *prod {
-		return "https://http1.golang.org"
-	}
-	return "http://" + httpHost()
-}
-
-func httpHost() string {
-	if *hostHTTP != "" {
-		return *hostHTTP
-	}
-	if v := *httpAddr; strings.HasPrefix(v, ":") {
-		return "localhost" + v
-	} else {
-		return v
-	}
-}
-
-func serveProdTLS(autocertManager *autocert.Manager) error {
-	srv := &http.Server{
-		TLSConfig: &tls.Config{
-			GetCertificate: autocertManager.GetCertificate,
-			GetConfigForClient: func(hello *tls.ClientHelloInfo) (*tls.Config, error) {
-				if hello.ServerName == "http1.golang.org" {
-					return &tls.Config{
-						GetCertificate: autocertManager.GetCertificate,
-					}, nil
-				}
-				return nil, nil // fallback to other methods
-			},
-		},
-	}
-	http2.ConfigureServer(srv, &http2.Server{
-		NewWriteScheduler: func() http2.WriteScheduler {
-			return http2.NewPriorityWriteScheduler(nil)
-		},
-	})
-	ln, err := net.Listen("tcp", ":443")
-	if err != nil {
-		return err
-	}
-	return srv.Serve(tls.NewListener(tcpKeepAliveListener{ln.(*net.TCPListener)}, srv.TLSConfig))
-}
-
-type tcpKeepAliveListener struct {
-	*net.TCPListener
-}
-
-func (ln tcpKeepAliveListener) Accept() (c net.Conn, err error) {
-	tc, err := ln.AcceptTCP()
-	if err != nil {
-		return
-	}
-	tc.SetKeepAlive(true)
-	tc.SetKeepAlivePeriod(3 * time.Minute)
-	return tc, nil
-}
-
-func serveProd() error {
-	log.Printf("running in production mode.")
-
-	storageClient, err := storage.NewClient(context.Background())
-	if err != nil {
-		log.Fatalf("storage.NewClient: %v", err)
-	}
-	autocertManager := &autocert.Manager{
-		Prompt:     autocert.AcceptTOS,
-		HostPolicy: autocert.HostWhitelist("http1.golang.org", "http2.golang.org"),
-		Cache:      autocertcache.NewGoogleCloudStorageCache(storageClient, "golang-h2demo-autocert"),
-		Email:      "golang-dev@googlegroups.com", // for lack of a better choice.
-	}
-
-	errc := make(chan error, 2)
-	go func() { errc <- http.ListenAndServe(":80", autocertManager.HTTPHandler(http.DefaultServeMux)) }()
-	go func() { errc <- serveProdTLS(autocertManager) }()
-	return <-errc
-}
-
-const idleTimeout = 5 * time.Minute
-const activeTimeout = 10 * time.Minute
-
-// TODO: put this into the standard library and actually send
-// PING frames and GOAWAY, etc: golang.org/issue/14204
-func idleTimeoutHook() func(net.Conn, http.ConnState) {
-	var mu sync.Mutex
-	m := map[net.Conn]*time.Timer{}
-	return func(c net.Conn, cs http.ConnState) {
-		mu.Lock()
-		defer mu.Unlock()
-		if t, ok := m[c]; ok {
-			delete(m, c)
-			t.Stop()
-		}
-		var d time.Duration
-		switch cs {
-		case http.StateNew, http.StateIdle:
-			d = idleTimeout
-		case http.StateActive:
-			d = activeTimeout
-		default:
-			return
-		}
-		m[c] = time.AfterFunc(d, func() {
-			log.Printf("closing idle conn %v after %v", c.RemoteAddr(), d)
-			go c.Close()
-		})
-	}
-}
-
-func main() {
-	var srv http.Server
-	flag.BoolVar(&http2.VerboseLogs, "verbose", false, "Verbose HTTP/2 debugging.")
-	flag.Parse()
-	srv.Addr = *httpsAddr
-	srv.ConnState = idleTimeoutHook()
-
-	registerHandlers()
-
-	if *prod {
-		*hostHTTP = "http2.golang.org"
-		*hostHTTPS = "http2.golang.org"
-		log.Fatal(serveProd())
-	}
-
-	url := "https://" + httpsHost() + "/"
-	log.Printf("Listening on " + url)
-	http2.ConfigureServer(&srv, &http2.Server{})
-
-	if *httpAddr != "" {
-		go func() {
-			log.Printf("Listening on http://" + httpHost() + "/ (for unencrypted HTTP/1)")
-			log.Fatal(http.ListenAndServe(*httpAddr, nil))
-		}()
-	}
-
-	go func() {
-		log.Fatal(srv.ListenAndServeTLS("server.crt", "server.key"))
-	}()
-	select {}
-}
diff --git a/http2/h2demo/rootCA.key b/http2/h2demo/rootCA.key
deleted file mode 100644
index a15a6ab..0000000
--- a/http2/h2demo/rootCA.key
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEAt5fAjp4fTcekWUTfzsp0kyih1OYbsGL0KX1eRbSSR8Od0+9Q
-62Hyny+GFwMTb4A/KU8mssoHvcceSAAbwfbxFK/+s51TobqUnORZrOoTZjkUygby
-XDSK99YBbcR1Pip8vwMTm4XKuLtCigeBBdjjAQdgUO28LENGlsMnmeYkJfODVGnV
-mr5Ltb9ANA8IKyTfsnHJ4iOCS/PlPbUj2q7YnoVLposUBMlgUb/CykX3mOoLb4yJ
-JQyA/iST6ZxiIEj36D4yWZ5lg7YJl+UiiBQHGCnPdGyipqV06ex0heYWcaiW8LWZ
-SUQ93jQ+WVCH8hT7DQO1dmsvUmXlq/JeAlwQ/QIDAQABAoIBAFFHV7JMAqPWnMYA
-nezY6J81v9+XN+7xABNWM2Q8uv4WdksbigGLTXR3/680Z2hXqJ7LMeC5XJACFT/e
-/Gr0vmpgOCygnCPfjGehGKpavtfksXV3edikUlnCXsOP1C//c1bFL+sMYmFCVgTx
-qYdDK8yKzXNGrKYT6q5YG7IglyRNV1rsQa8lM/5taFYiD1Ck/3tQi3YIq8Lcuser
-hrxsMABcQ6mi+EIvG6Xr4mfJug0dGJMHG4RG1UGFQn6RXrQq2+q53fC8ZbVUSi0j
-NQ918aKFzktwv+DouKU0ME4I9toks03gM860bAL7zCbKGmwR3hfgX/TqzVCWpG9E
-LDVfvekCgYEA8fk9N53jbBRmULUGEf4qWypcLGiZnNU0OeXWpbPV9aa3H0VDytA7
-8fCN2dPAVDPqlthMDdVe983NCNwp2Yo8ZimDgowyIAKhdC25s1kejuaiH9OAPj3c
-0f8KbriYX4n8zNHxFwK6Ae3pQ6EqOLJVCUsziUaZX9nyKY5aZlyX6xcCgYEAwjws
-K62PjC64U5wYddNLp+kNdJ4edx+a7qBb3mEgPvSFT2RO3/xafJyG8kQB30Mfstjd
-bRxyUV6N0vtX1zA7VQtRUAvfGCecpMo+VQZzcHXKzoRTnQ7eZg4Lmj5fQ9tOAKAo
-QCVBoSW/DI4PZL26CAMDcAba4Pa22ooLapoRIQsCgYA6pIfkkbxLNkpxpt2YwLtt
-Kr/590O7UaR9n6k8sW/aQBRDXNsILR1KDl2ifAIxpf9lnXgZJiwE7HiTfCAcW7c1
-nzwDCI0hWuHcMTS/NYsFYPnLsstyyjVZI3FY0h4DkYKV9Q9z3zJLQ2hz/nwoD3gy
-b2pHC7giFcTts1VPV4Nt8wKBgHeFn4ihHJweg76vZz3Z78w7VNRWGFklUalVdDK7
-gaQ7w2y/ROn/146mo0OhJaXFIFRlrpvdzVrU3GDf2YXJYDlM5ZRkObwbZADjksev
-WInzcgDy3KDg7WnPasRXbTfMU4t/AkW2p1QKbi3DnSVYuokDkbH2Beo45vxDxhKr
-C69RAoGBAIyo3+OJenoZmoNzNJl2WPW5MeBUzSh8T/bgyjFTdqFHF5WiYRD/lfHj
-x9Glyw2nutuT4hlOqHvKhgTYdDMsF2oQ72fe3v8Q5FU7FuKndNPEAyvKNXZaShVA
-hnlhv5DjXKb0wFWnt5PCCiQLtzG0yyHaITrrEme7FikkIcTxaX/Y
------END RSA PRIVATE KEY-----
diff --git a/http2/h2demo/rootCA.pem b/http2/h2demo/rootCA.pem
deleted file mode 100644
index 3a323e7..0000000
--- a/http2/h2demo/rootCA.pem
+++ /dev/null
@@ -1,26 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIEWjCCA0KgAwIBAgIJALfRlWsI8YQHMA0GCSqGSIb3DQEBBQUAMHsxCzAJBgNV
-BAYTAlVTMQswCQYDVQQIEwJDQTEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzEUMBIG
-A1UEChMLQnJhZGZpdHppbmMxEjAQBgNVBAMTCWxvY2FsaG9zdDEdMBsGCSqGSIb3
-DQEJARYOYnJhZEBkYW5nYS5jb20wHhcNMTQwNzE1MjA0NjA1WhcNMTcwNTA0MjA0
-NjA1WjB7MQswCQYDVQQGEwJVUzELMAkGA1UECBMCQ0ExFjAUBgNVBAcTDVNhbiBG
-cmFuY2lzY28xFDASBgNVBAoTC0JyYWRmaXR6aW5jMRIwEAYDVQQDEwlsb2NhbGhv
-c3QxHTAbBgkqhkiG9w0BCQEWDmJyYWRAZGFuZ2EuY29tMIIBIjANBgkqhkiG9w0B
-AQEFAAOCAQ8AMIIBCgKCAQEAt5fAjp4fTcekWUTfzsp0kyih1OYbsGL0KX1eRbSS
-R8Od0+9Q62Hyny+GFwMTb4A/KU8mssoHvcceSAAbwfbxFK/+s51TobqUnORZrOoT
-ZjkUygbyXDSK99YBbcR1Pip8vwMTm4XKuLtCigeBBdjjAQdgUO28LENGlsMnmeYk
-JfODVGnVmr5Ltb9ANA8IKyTfsnHJ4iOCS/PlPbUj2q7YnoVLposUBMlgUb/CykX3
-mOoLb4yJJQyA/iST6ZxiIEj36D4yWZ5lg7YJl+UiiBQHGCnPdGyipqV06ex0heYW
-caiW8LWZSUQ93jQ+WVCH8hT7DQO1dmsvUmXlq/JeAlwQ/QIDAQABo4HgMIHdMB0G
-A1UdDgQWBBRcAROthS4P4U7vTfjByC569R7E6DCBrQYDVR0jBIGlMIGigBRcAROt
-hS4P4U7vTfjByC569R7E6KF/pH0wezELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAkNB
-MRYwFAYDVQQHEw1TYW4gRnJhbmNpc2NvMRQwEgYDVQQKEwtCcmFkZml0emluYzES
-MBAGA1UEAxMJbG9jYWxob3N0MR0wGwYJKoZIhvcNAQkBFg5icmFkQGRhbmdhLmNv
-bYIJALfRlWsI8YQHMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAG6h
-U9f9sNH0/6oBbGGy2EVU0UgITUQIrFWo9rFkrW5k/XkDjQm+3lzjT0iGR4IxE/Ao
-eU6sQhua7wrWeFEn47GL98lnCsJdD7oZNhFmQ95Tb/LnDUjs5Yj9brP0NWzXfYU4
-UK2ZnINJRcJpB8iRCaCxE8DdcUF0XqIEq6pA272snoLmiXLMvNl3kYEdm+je6voD
-58SNVEUsztzQyXmJEhCpwVI0A6QCjzXj+qvpmw3ZZHi8JwXei8ZZBLTSFBki8Z7n
-sH9BBH38/SzUmAN4QHSPy1gjqm00OAE8NaYDkh/bzE4d7mLGGMWp/WE3KPSu82HF
-kPe6XoSbiLm/kxk32T0=
------END CERTIFICATE-----
diff --git a/http2/h2demo/rootCA.srl b/http2/h2demo/rootCA.srl
deleted file mode 100644
index 6db3891..0000000
--- a/http2/h2demo/rootCA.srl
+++ /dev/null
@@ -1 +0,0 @@
-E2CE26BF3285059C
diff --git a/http2/h2demo/server.crt b/http2/h2demo/server.crt
deleted file mode 100644
index c59059b..0000000
--- a/http2/h2demo/server.crt
+++ /dev/null
@@ -1,20 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDPjCCAiYCCQDizia/MoUFnDANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJV
-UzELMAkGA1UECBMCQ0ExFjAUBgNVBAcTDVNhbiBGcmFuY2lzY28xFDASBgNVBAoT
-C0JyYWRmaXR6aW5jMRIwEAYDVQQDEwlsb2NhbGhvc3QxHTAbBgkqhkiG9w0BCQEW
-DmJyYWRAZGFuZ2EuY29tMB4XDTE0MDcxNTIwNTAyN1oXDTE1MTEyNzIwNTAyN1ow
-RzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAkNBMQswCQYDVQQHEwJTRjEeMBwGA1UE
-ChMVYnJhZGZpdHogaHR0cDIgc2VydmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
-MIIBCgKCAQEAs1Y9CyLFrdL8VQWN1WaifDqaZFnoqjHhCMlc1TfG2zA+InDifx2l
-gZD3o8FeNnAcfM2sPlk3+ZleOYw9P/CklFVDlvqmpCv9ss/BEp/dDaWvy1LmJ4c2
-dbQJfmTxn7CV1H3TsVJvKdwFmdoABb41NoBp6+NNO7OtDyhbIMiCI0pL3Nefb3HL
-A7hIMo3DYbORTtJLTIH9W8YKrEWL0lwHLrYFx/UdutZnv+HjdmO6vCN4na55mjws
-/vjKQUmc7xeY7Xe20xDEG2oDKVkL2eD7FfyrYMS3rO1ExP2KSqlXYG/1S9I/fz88
-F0GK7HX55b5WjZCl2J3ERVdnv/0MQv+sYQIDAQABMA0GCSqGSIb3DQEBBQUAA4IB
-AQC0zL+n/YpRZOdulSu9tS8FxrstXqGWoxfe+vIUgqfMZ5+0MkjJ/vW0FqlLDl2R
-rn4XaR3e7FmWkwdDVbq/UB6lPmoAaFkCgh9/5oapMaclNVNnfF3fjCJfRr+qj/iD
-EmJStTIN0ZuUjAlpiACmfnpEU55PafT5Zx+i1yE4FGjw8bJpFoyD4Hnm54nGjX19
-KeCuvcYFUPnBm3lcL0FalF2AjqV02WTHYNQk7YF/oeO7NKBoEgvGvKG3x+xaOeBI
-dwvdq175ZsGul30h+QjrRlXhH/twcuaT3GSdoysDl9cCYE8f1Mk8PD6gan3uBCJU
-90p6/CbU71bGbfpM2PHot2fm
------END CERTIFICATE-----
diff --git a/http2/h2demo/server.key b/http2/h2demo/server.key
deleted file mode 100644
index f329c14..0000000
--- a/http2/h2demo/server.key
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEAs1Y9CyLFrdL8VQWN1WaifDqaZFnoqjHhCMlc1TfG2zA+InDi
-fx2lgZD3o8FeNnAcfM2sPlk3+ZleOYw9P/CklFVDlvqmpCv9ss/BEp/dDaWvy1Lm
-J4c2dbQJfmTxn7CV1H3TsVJvKdwFmdoABb41NoBp6+NNO7OtDyhbIMiCI0pL3Nef
-b3HLA7hIMo3DYbORTtJLTIH9W8YKrEWL0lwHLrYFx/UdutZnv+HjdmO6vCN4na55
-mjws/vjKQUmc7xeY7Xe20xDEG2oDKVkL2eD7FfyrYMS3rO1ExP2KSqlXYG/1S9I/
-fz88F0GK7HX55b5WjZCl2J3ERVdnv/0MQv+sYQIDAQABAoIBADQ2spUwbY+bcz4p
-3M66ECrNQTBggP40gYl2XyHxGGOu2xhZ94f9ELf1hjRWU2DUKWco1rJcdZClV6q3
-qwmXvcM2Q/SMS8JW0ImkNVl/0/NqPxGatEnj8zY30d/L8hGFb0orzFu/XYA5gCP4
-NbN2WrXgk3ZLeqwcNxHHtSiJWGJ/fPyeDWAu/apy75u9Xf2GlzBZmV6HYD9EfK80
-LTlI60f5FO487CrJnboL7ovPJrIHn+k05xRQqwma4orpz932rTXnTjs9Lg6KtbQN
-a7PrqfAntIISgr11a66Mng3IYH1lYqJsWJJwX/xHT4WLEy0EH4/0+PfYemJekz2+
-Co62drECgYEA6O9zVJZXrLSDsIi54cfxA7nEZWm5CAtkYWeAHa4EJ+IlZ7gIf9sL
-W8oFcEfFGpvwVqWZ+AsQ70dsjXAv3zXaG0tmg9FtqWp7pzRSMPidifZcQwWkKeTO
-gJnFmnVyed8h6GfjTEu4gxo1/S5U0V+mYSha01z5NTnN6ltKx1Or3b0CgYEAxRgm
-S30nZxnyg/V7ys61AZhst1DG2tkZXEMcA7dYhabMoXPJAP/EfhlWwpWYYUs/u0gS
-Wwmf5IivX5TlYScgmkvb/NYz0u4ZmOXkLTnLPtdKKFXhjXJcHjUP67jYmOxNlJLp
-V4vLRnFxTpffAV+OszzRxsXX6fvruwZBANYJeXUCgYBVouLFsFgfWGYp2rpr9XP4
-KK25kvrBqF6JKOIDB1zjxNJ3pUMKrl8oqccCFoCyXa4oTM2kUX0yWxHfleUjrMq4
-yimwQKiOZmV7fVLSSjSw6e/VfBd0h3gb82ygcplZkN0IclkwTY5SNKqwn/3y07V5
-drqdhkrgdJXtmQ6O5YYECQKBgATERcDToQ1USlI4sKrB/wyv1AlG8dg/IebiVJ4e
-ZAyvcQmClFzq0qS+FiQUnB/WQw9TeeYrwGs1hxBHuJh16srwhLyDrbMvQP06qh8R
-48F8UXXSRec22dV9MQphaROhu2qZdv1AC0WD3tqov6L33aqmEOi+xi8JgbT/PLk5
-c/c1AoGBAI1A/02ryksW6/wc7/6SP2M2rTy4m1sD/GnrTc67EHnRcVBdKO6qH2RY
-nqC8YcveC2ZghgPTDsA3VGuzuBXpwY6wTyV99q6jxQJ6/xcrD9/NUG6Uwv/xfCxl
-IJLeBYEqQundSSny3VtaAUK8Ul1nxpTvVRNwtcyWTo8RHAAyNPWd
------END RSA PRIVATE KEY-----
diff --git a/http2/h2demo/service.yaml b/http2/h2demo/service.yaml
deleted file mode 100644
index 82c3254..0000000
--- a/http2/h2demo/service.yaml
+++ /dev/null
@@ -1,18 +0,0 @@
-apiVersion: v1
-kind: Service
-metadata:
-  namespace: prod
-  name: h2demo
-spec:
-  externalTrafficPolicy: Local
-  ports:
-    - port: 80
-      targetPort: 80
-      name: http
-    - port: 443
-      targetPort: 443
-      name: https
-  selector:
-    app: h2demo
-  type: LoadBalancer
-  loadBalancerIP: 130.211.116.44
diff --git a/http2/h2demo/tmpl.go b/http2/h2demo/tmpl.go
deleted file mode 100644
index d898c1f..0000000
--- a/http2/h2demo/tmpl.go
+++ /dev/null
@@ -1,1989 +0,0 @@
-// 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.
-
-package main
-
-import "html/template"
-
-var pushTmpl = template.Must(template.New("serverpush").Parse(`
-
-<!DOCTYPE html>
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<meta name="theme-color" content="#375EAB">
-
-  <title>HTTP/2 Server Push Demo</title>
-
-<link type="text/css" rel="stylesheet" href="/serverpush/static/style.css?{{.CacheBust}}">
-<script>
-window.initFuncs = [];
-</script>
-
-<script>
-function showtimes() {
-	var times = 'DOM loaded: ' + (window.performance.timing.domContentLoadedEventEnd - window.performance.timing.navigationStart) + 'ms, '
-	times += 'DOM complete (all loaded): ' + (window.performance.timing.domComplete - window.performance.timing.navigationStart) + 'ms, '
-	times += 'Load event fired: ' + (window.performance.timing.loadEventStart - window.performance.timing.navigationStart) + 'ms'
-	document.getElementById('loadtimes').innerHTML = times
-}
-</script>
-
-</head>
-<body onload="showtimes()">
-
-<div style="background:#fff9a4;padding:10px">
-Note: This page exists for demonstration purposes. For the actual cmd/go docs, go to <a href="golang.org/cmd/go">golang.org/cmd/go</a>.
-</div>
-
-<div style="padding:20px">
-
-
-<a href="https://{{.HTTPSHost}}/serverpush">HTTP/2 with Server Push</a> | <a href="{{.HTTP1Prefix}}/serverpush">HTTP only</a>
-<div id="loadtimes"></div>
-
-</div>
-
-<div id='lowframe' style="position: fixed; bottom: 0; left: 0; height: 0; width: 100%; border-top: thin solid grey; background-color: white; overflow: auto;">
-...
-</div><!-- #lowframe -->
-
-<div id="topbar" class="wide"><div class="container">
-<div class="top-heading" id="heading-wide"><a href="/">The Go Programming Language</a></div>
-<div class="top-heading" id="heading-narrow"><a href="/">Go</a></div>
-<a href="#" id="menu-button"><span id="menu-button-arrow">&#9661;</span></a>
-<form method="GET" action="/search">
-<div id="menu">
-<a href="/doc/">Documents</a>
-<a href="/pkg/">Packages</a>
-<a href="/project/">The Project</a>
-<a href="/help/">Help</a>
-<a href="/blog/">Blog</a>
-
-<a id="playgroundButton" href="http://play.golang.org/" title="Show Go Playground">Play</a>
-
-<input type="text" id="search" name="q" class="inactive" value="Search" placeholder="Search">
-</div>
-</form>
-
-</div></div>
-
-
-<div id="playground" class="play">
-	<div class="input"><textarea class="code" spellcheck="false">package main
-
-import "fmt"
-
-func main() {
-	fmt.Println("Hello, 世界")
-}</textarea></div>
-	<div class="output"></div>
-	<div class="buttons">
-		<a class="run" title="Run this code [shift-enter]">Run</a>
-		<a class="fmt" title="Format this code">Format</a>
-		
-		<a class="share" title="Share this code">Share</a>
-		
-	</div>
-</div>
-
-
-<div id="page" class="wide">
-<div class="container">
-
-
-  <h1>Command go</h1>
-
-
-
-
-<div id="nav"></div>
-
-
-<!--
-	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.
--->
-<!--
-	Note: Static (i.e., not template-generated) href and id
-	attributes start with "pkg-" to make it impossible for
-	them to conflict with generated attributes (some of which
-	correspond to Go identifiers).
--->
-
-	<script type='text/javascript'>
-	document.ANALYSIS_DATA = null;
-	document.CALLGRAPH = null;
-	</script>
-
-	
-		
-		<p>
-Go is a tool for managing Go source code.
-</p>
-<p>
-Usage:
-</p>
-<pre>go command [arguments]
-</pre>
-<p>
-The commands are:
-</p>
-<pre>build       compile packages and dependencies
-clean       remove object files
-doc         show documentation for package or symbol
-env         print Go environment information
-bug         start a bug report
-fix         run go tool fix on packages
-fmt         run gofmt on package sources
-generate    generate Go files by processing source
-get         download and install packages and dependencies
-install     compile and install packages and dependencies
-list        list packages
-run         compile and run Go program
-test        test packages
-tool        run specified go tool
-version     print Go version
-vet         run go tool vet on packages
-</pre>
-<p>
-Use &#34;go help [command]&#34; for more information about a command.
-</p>
-<p>
-Additional help topics:
-</p>
-<pre>c           calling between Go and C
-buildmode   description of build modes
-filetype    file types
-gopath      GOPATH environment variable
-environment environment variables
-importpath  import path syntax
-packages    description of package lists
-testflag    description of testing flags
-testfunc    description of testing functions
-</pre>
-<p>
-Use &#34;go help [topic]&#34; for more information about that topic.
-</p>
-<h3 id="hdr-Compile_packages_and_dependencies">Compile packages and dependencies</h3>
-<p>
-Usage:
-</p>
-<pre>go build [-o output] [-i] [build flags] [packages]
-</pre>
-<p>
-Build compiles the packages named by the import paths,
-along with their dependencies, but it does not install the results.
-</p>
-<p>
-If the arguments to build are a list of .go files, build treats
-them as a list of source files specifying a single package.
-</p>
-<p>
-When compiling a single main package, build writes
-the resulting executable to an output file named after
-the first source file (&#39;go build ed.go rx.go&#39; writes &#39;ed&#39; or &#39;ed.exe&#39;)
-or the source code directory (&#39;go build unix/sam&#39; writes &#39;sam&#39; or &#39;sam.exe&#39;).
-The &#39;.exe&#39; suffix is added when writing a Windows executable.
-</p>
-<p>
-When compiling multiple packages or a single non-main package,
-build compiles the packages but discards the resulting object,
-serving only as a check that the packages can be built.
-</p>
-<p>
-When compiling packages, build ignores files that end in &#39;_test.go&#39;.
-</p>
-<p>
-The -o flag, only allowed when compiling a single package,
-forces build to write the resulting executable or object
-to the named output file, instead of the default behavior described
-in the last two paragraphs.
-</p>
-<p>
-The -i flag installs the packages that are dependencies of the target.
-</p>
-<p>
-The build flags are shared by the build, clean, get, install, list, run,
-and test commands:
-</p>
-<pre>-a
-	force rebuilding of packages that are already up-to-date.
--n
-	print the commands but do not run them.
--p n
-	the number of programs, such as build commands or
-	test binaries, that can be run in parallel.
-	The default is the number of CPUs available.
--race
-	enable data race detection.
-	Supported only on linux/amd64, freebsd/amd64, darwin/amd64 and windows/amd64.
--msan
-	enable interoperation with memory sanitizer.
-	Supported only on linux/amd64,
-	and only with Clang/LLVM as the host C compiler.
--v
-	print the names of packages as they are compiled.
--work
-	print the name of the temporary work directory and
-	do not delete it when exiting.
--x
-	print the commands.
-
--asmflags &#39;flag list&#39;
-	arguments to pass on each go tool asm invocation.
--buildmode mode
-	build mode to use. See &#39;go help buildmode&#39; for more.
--compiler name
-	name of compiler to use, as in runtime.Compiler (gccgo or gc).
--gccgoflags &#39;arg list&#39;
-	arguments to pass on each gccgo compiler/linker invocation.
--gcflags &#39;arg list&#39;
-	arguments to pass on each go tool compile invocation.
--installsuffix suffix
-	a suffix to use in the name of the package installation directory,
-	in order to keep output separate from default builds.
-	If using the -race flag, the install suffix is automatically set to race
-	or, if set explicitly, has _race appended to it.  Likewise for the -msan
-	flag.  Using a -buildmode option that requires non-default compile flags
-	has a similar effect.
--ldflags &#39;flag list&#39;
-	arguments to pass on each go tool link invocation.
--linkshared
-	link against shared libraries previously created with
-	-buildmode=shared.
--pkgdir dir
-	install and load all packages from dir instead of the usual locations.
-	For example, when building with a non-standard configuration,
-	use -pkgdir to keep generated packages in a separate location.
--tags &#39;tag list&#39;
-	a list of build tags to consider satisfied during the build.
-	For more information about build tags, see the description of
-	build constraints in the documentation for the go/build package.
--toolexec &#39;cmd args&#39;
-	a program to use to invoke toolchain programs like vet and asm.
-	For example, instead of running asm, the go command will run
-	&#39;cmd args /path/to/asm &lt;arguments for asm&gt;&#39;.
-</pre>
-<p>
-The list flags accept a space-separated list of strings. To embed spaces
-in an element in the list, surround it with either single or double quotes.
-</p>
-<p>
-For more about specifying packages, see &#39;go help packages&#39;.
-For more about where packages and binaries are installed,
-run &#39;go help gopath&#39;.
-For more about calling between Go and C/C++, run &#39;go help c&#39;.
-</p>
-<p>
-Note: Build adheres to certain conventions such as those described
-by &#39;go help gopath&#39;. Not all projects can follow these conventions,
-however. Installations that have their own conventions or that use
-a separate software build system may choose to use lower-level
-invocations such as &#39;go tool compile&#39; and &#39;go tool link&#39; to avoid
-some of the overheads and design decisions of the build tool.
-</p>
-<p>
-See also: go install, go get, go clean.
-</p>
-<h3 id="hdr-Remove_object_files">Remove object files</h3>
-<p>
-Usage:
-</p>
-<pre>go clean [-i] [-r] [-n] [-x] [build flags] [packages]
-</pre>
-<p>
-Clean removes object files from package source directories.
-The go command builds most objects in a temporary directory,
-so go clean is mainly concerned with object files left by other
-tools or by manual invocations of go build.
-</p>
-<p>
-Specifically, clean removes the following files from each of the
-source directories corresponding to the import paths:
-</p>
-<pre>_obj/            old object directory, left from Makefiles
-_test/           old test directory, left from Makefiles
-_testmain.go     old gotest file, left from Makefiles
-test.out         old test log, left from Makefiles
-build.out        old test log, left from Makefiles
-*.[568ao]        object files, left from Makefiles
-
-DIR(.exe)        from go build
-DIR.test(.exe)   from go test -c
-MAINFILE(.exe)   from go build MAINFILE.go
-*.so             from SWIG
-</pre>
-<p>
-In the list, DIR represents the final path element of the
-directory, and MAINFILE is the base name of any Go source
-file in the directory that is not included when building
-the package.
-</p>
-<p>
-The -i flag causes clean to remove the corresponding installed
-archive or binary (what &#39;go install&#39; would create).
-</p>
-<p>
-The -n flag causes clean to print the remove commands it would execute,
-but not run them.
-</p>
-<p>
-The -r flag causes clean to be applied recursively to all the
-dependencies of the packages named by the import paths.
-</p>
-<p>
-The -x flag causes clean to print remove commands as it executes them.
-</p>
-<p>
-For more about build flags, see &#39;go help build&#39;.
-</p>
-<p>
-For more about specifying packages, see &#39;go help packages&#39;.
-</p>
-<h3 id="hdr-Show_documentation_for_package_or_symbol">Show documentation for package or symbol</h3>
-<p>
-Usage:
-</p>
-<pre>go doc [-u] [-c] [package|[package.]symbol[.method]]
-</pre>
-<p>
-Doc prints the documentation comments associated with the item identified by its
-arguments (a package, const, func, type, var, or method) followed by a one-line
-summary of each of the first-level items &#34;under&#34; that item (package-level
-declarations for a package, methods for a type, etc.).
-</p>
-<p>
-Doc accepts zero, one, or two arguments.
-</p>
-<p>
-Given no arguments, that is, when run as
-</p>
-<pre>go doc
-</pre>
-<p>
-it prints the package documentation for the package in the current directory.
-If the package is a command (package main), the exported symbols of the package
-are elided from the presentation unless the -cmd flag is provided.
-</p>
-<p>
-When run with one argument, the argument is treated as a Go-syntax-like
-representation of the item to be documented. What the argument selects depends
-on what is installed in GOROOT and GOPATH, as well as the form of the argument,
-which is schematically one of these:
-</p>
-<pre>go doc &lt;pkg&gt;
-go doc &lt;sym&gt;[.&lt;method&gt;]
-go doc [&lt;pkg&gt;.]&lt;sym&gt;[.&lt;method&gt;]
-go doc [&lt;pkg&gt;.][&lt;sym&gt;.]&lt;method&gt;
-</pre>
-<p>
-The first item in this list matched by the argument is the one whose documentation
-is printed. (See the examples below.) However, if the argument starts with a capital
-letter it is assumed to identify a symbol or method in the current directory.
-</p>
-<p>
-For packages, the order of scanning is determined lexically in breadth-first order.
-That is, the package presented is the one that matches the search and is nearest
-the root and lexically first at its level of the hierarchy.  The GOROOT tree is
-always scanned in its entirety before GOPATH.
-</p>
-<p>
-If there is no package specified or matched, the package in the current
-directory is selected, so &#34;go doc Foo&#34; shows the documentation for symbol Foo in
-the current package.
-</p>
-<p>
-The package path must be either a qualified path or a proper suffix of a
-path. The go tool&#39;s usual package mechanism does not apply: package path
-elements like . and ... are not implemented by go doc.
-</p>
-<p>
-When run with two arguments, the first must be a full package path (not just a
-suffix), and the second is a symbol or symbol and method; this is similar to the
-syntax accepted by godoc:
-</p>
-<pre>go doc &lt;pkg&gt; &lt;sym&gt;[.&lt;method&gt;]
-</pre>
-<p>
-In all forms, when matching symbols, lower-case letters in the argument match
-either case but upper-case letters match exactly. This means that there may be
-multiple matches of a lower-case argument in a package if different symbols have
-different cases. If this occurs, documentation for all matches is printed.
-</p>
-<p>
-Examples:
-</p>
-<pre>go doc
-	Show documentation for current package.
-go doc Foo
-	Show documentation for Foo in the current package.
-	(Foo starts with a capital letter so it cannot match
-	a package path.)
-go doc encoding/json
-	Show documentation for the encoding/json package.
-go doc json
-	Shorthand for encoding/json.
-go doc json.Number (or go doc json.number)
-	Show documentation and method summary for json.Number.
-go doc json.Number.Int64 (or go doc json.number.int64)
-	Show documentation for json.Number&#39;s Int64 method.
-go doc cmd/doc
-	Show package docs for the doc command.
-go doc -cmd cmd/doc
-	Show package docs and exported symbols within the doc command.
-go doc template.new
-	Show documentation for html/template&#39;s New function.
-	(html/template is lexically before text/template)
-go doc text/template.new # One argument
-	Show documentation for text/template&#39;s New function.
-go doc text/template new # Two arguments
-	Show documentation for text/template&#39;s New function.
-
-At least in the current tree, these invocations all print the
-documentation for json.Decoder&#39;s Decode method:
-
-go doc json.Decoder.Decode
-go doc json.decoder.decode
-go doc json.decode
-cd go/src/encoding/json; go doc decode
-</pre>
-<p>
-Flags:
-</p>
-<pre>-c
-	Respect case when matching symbols.
--cmd
-	Treat a command (package main) like a regular package.
-	Otherwise package main&#39;s exported symbols are hidden
-	when showing the package&#39;s top-level documentation.
--u
-	Show documentation for unexported as well as exported
-	symbols and methods.
-</pre>
-<h3 id="hdr-Print_Go_environment_information">Print Go environment information</h3>
-<p>
-Usage:
-</p>
-<pre>go env [var ...]
-</pre>
-<p>
-Env prints Go environment information.
-</p>
-<p>
-By default env prints information as a shell script
-(on Windows, a batch file).  If one or more variable
-names is given as arguments,  env prints the value of
-each named variable on its own line.
-</p>
-<h3 id="hdr-Start_a_bug_report">Start a bug report</h3>
-<p>
-Usage:
-</p>
-<pre>go bug
-</pre>
-<p>
-Bug opens the default browser and starts a new bug report.
-The report includes useful system information.
-</p>
-<h3 id="hdr-Run_go_tool_fix_on_packages">Run go tool fix on packages</h3>
-<p>
-Usage:
-</p>
-<pre>go fix [packages]
-</pre>
-<p>
-Fix runs the Go fix command on the packages named by the import paths.
-</p>
-<p>
-For more about fix, see &#39;go doc cmd/fix&#39;.
-For more about specifying packages, see &#39;go help packages&#39;.
-</p>
-<p>
-To run fix with specific options, run &#39;go tool fix&#39;.
-</p>
-<p>
-See also: go fmt, go vet.
-</p>
-<h3 id="hdr-Run_gofmt_on_package_sources">Run gofmt on package sources</h3>
-<p>
-Usage:
-</p>
-<pre>go fmt [-n] [-x] [packages]
-</pre>
-<p>
-Fmt runs the command &#39;gofmt -l -w&#39; on the packages named
-by the import paths.  It prints the names of the files that are modified.
-</p>
-<p>
-For more about gofmt, see &#39;go doc cmd/gofmt&#39;.
-For more about specifying packages, see &#39;go help packages&#39;.
-</p>
-<p>
-The -n flag prints commands that would be executed.
-The -x flag prints commands as they are executed.
-</p>
-<p>
-To run gofmt with specific options, run gofmt itself.
-</p>
-<p>
-See also: go fix, go vet.
-</p>
-<h3 id="hdr-Generate_Go_files_by_processing_source">Generate Go files by processing source</h3>
-<p>
-Usage:
-</p>
-<pre>go generate [-run regexp] [-n] [-v] [-x] [build flags] [file.go... | packages]
-</pre>
-<p>
-Generate runs commands described by directives within existing
-files. Those commands can run any process but the intent is to
-create or update Go source files.
-</p>
-<p>
-Go generate is never run automatically by go build, go get, go test,
-and so on. It must be run explicitly.
-</p>
-<p>
-Go generate scans the file for directives, which are lines of
-the form,
-</p>
-<pre>//go:generate command argument...
-</pre>
-<p>
-(note: no leading spaces and no space in &#34;//go&#34;) where command
-is the generator to be run, corresponding to an executable file
-that can be run locally. It must either be in the shell path
-(gofmt), a fully qualified path (/usr/you/bin/mytool), or a
-command alias, described below.
-</p>
-<p>
-Note that go generate does not parse the file, so lines that look
-like directives in comments or multiline strings will be treated
-as directives.
-</p>
-<p>
-The arguments to the directive are space-separated tokens or
-double-quoted strings passed to the generator as individual
-arguments when it is run.
-</p>
-<p>
-Quoted strings use Go syntax and are evaluated before execution; a
-quoted string appears as a single argument to the generator.
-</p>
-<p>
-Go generate sets several variables when it runs the generator:
-</p>
-<pre>$GOARCH
-	The execution architecture (arm, amd64, etc.)
-$GOOS
-	The execution operating system (linux, windows, etc.)
-$GOFILE
-	The base name of the file.
-$GOLINE
-	The line number of the directive in the source file.
-$GOPACKAGE
-	The name of the package of the file containing the directive.
-$DOLLAR
-	A dollar sign.
-</pre>
-<p>
-Other than variable substitution and quoted-string evaluation, no
-special processing such as &#34;globbing&#34; is performed on the command
-line.
-</p>
-<p>
-As a last step before running the command, any invocations of any
-environment variables with alphanumeric names, such as $GOFILE or
-$HOME, are expanded throughout the command line. The syntax for
-variable expansion is $NAME on all operating systems.  Due to the
-order of evaluation, variables are expanded even inside quoted
-strings. If the variable NAME is not set, $NAME expands to the
-empty string.
-</p>
-<p>
-A directive of the form,
-</p>
-<pre>//go:generate -command xxx args...
-</pre>
-<p>
-specifies, for the remainder of this source file only, that the
-string xxx represents the command identified by the arguments. This
-can be used to create aliases or to handle multiword generators.
-For example,
-</p>
-<pre>//go:generate -command foo go tool foo
-</pre>
-<p>
-specifies that the command &#34;foo&#34; represents the generator
-&#34;go tool foo&#34;.
-</p>
-<p>
-Generate processes packages in the order given on the command line,
-one at a time. If the command line lists .go files, they are treated
-as a single package. Within a package, generate processes the
-source files in a package in file name order, one at a time. Within
-a source file, generate runs generators in the order they appear
-in the file, one at a time.
-</p>
-<p>
-If any generator returns an error exit status, &#34;go generate&#34; skips
-all further processing for that package.
-</p>
-<p>
-The generator is run in the package&#39;s source directory.
-</p>
-<p>
-Go generate accepts one specific flag:
-</p>
-<pre>-run=&#34;&#34;
-	if non-empty, specifies a regular expression to select
-	directives whose full original source text (excluding
-	any trailing spaces and final newline) matches the
-	expression.
-</pre>
-<p>
-It also accepts the standard build flags including -v, -n, and -x.
-The -v flag prints the names of packages and files as they are
-processed.
-The -n flag prints commands that would be executed.
-The -x flag prints commands as they are executed.
-</p>
-<p>
-For more about build flags, see &#39;go help build&#39;.
-</p>
-<p>
-For more about specifying packages, see &#39;go help packages&#39;.
-</p>
-<h3 id="hdr-Download_and_install_packages_and_dependencies">Download and install packages and dependencies</h3>
-<p>
-Usage:
-</p>
-<pre>go get [-d] [-f] [-fix] [-insecure] [-t] [-u] [build flags] [packages]
-</pre>
-<p>
-Get downloads the packages named by the import paths, along with their
-dependencies. It then installs the named packages, like &#39;go install&#39;.
-</p>
-<p>
-The -d flag instructs get to stop after downloading the packages; that is,
-it instructs get not to install the packages.
-</p>
-<p>
-The -f flag, valid only when -u is set, forces get -u not to verify that
-each package has been checked out from the source control repository
-implied by its import path. This can be useful if the source is a local fork
-of the original.
-</p>
-<p>
-The -fix flag instructs get to run the fix tool on the downloaded packages
-before resolving dependencies or building the code.
-</p>
-<p>
-The -insecure flag permits fetching from repositories and resolving
-custom domains using insecure schemes such as HTTP. Use with caution.
-</p>
-<p>
-The -t flag instructs get to also download the packages required to build
-the tests for the specified packages.
-</p>
-<p>
-The -u flag instructs get to use the network to update the named packages
-and their dependencies.  By default, get uses the network to check out
-missing packages but does not use it to look for updates to existing packages.
-</p>
-<p>
-The -v flag enables verbose progress and debug output.
-</p>
-<p>
-Get also accepts build flags to control the installation. See &#39;go help build&#39;.
-</p>
-<p>
-When checking out a new package, get creates the target directory
-GOPATH/src/&lt;import-path&gt;. If the GOPATH contains multiple entries,
-get uses the first one. For more details see: &#39;go help gopath&#39;.
-</p>
-<p>
-When checking out or updating a package, get looks for a branch or tag
-that matches the locally installed version of Go. The most important
-rule is that if the local installation is running version &#34;go1&#34;, get
-searches for a branch or tag named &#34;go1&#34;. If no such version exists it
-retrieves the most recent version of the package.
-</p>
-<p>
-When go get checks out or updates a Git repository,
-it also updates any git submodules referenced by the repository.
-</p>
-<p>
-Get never checks out or updates code stored in vendor directories.
-</p>
-<p>
-For more about specifying packages, see &#39;go help packages&#39;.
-</p>
-<p>
-For more about how &#39;go get&#39; finds source code to
-download, see &#39;go help importpath&#39;.
-</p>
-<p>
-See also: go build, go install, go clean.
-</p>
-<h3 id="hdr-Compile_and_install_packages_and_dependencies">Compile and install packages and dependencies</h3>
-<p>
-Usage:
-</p>
-<pre>go install [build flags] [packages]
-</pre>
-<p>
-Install compiles and installs the packages named by the import paths,
-along with their dependencies.
-</p>
-<p>
-For more about the build flags, see &#39;go help build&#39;.
-For more about specifying packages, see &#39;go help packages&#39;.
-</p>
-<p>
-See also: go build, go get, go clean.
-</p>
-<h3 id="hdr-List_packages">List packages</h3>
-<p>
-Usage:
-</p>
-<pre>go list [-e] [-f format] [-json] [build flags] [packages]
-</pre>
-<p>
-List lists the packages named by the import paths, one per line.
-</p>
-<p>
-The default output shows the package import path:
-</p>
-<pre>bytes
-encoding/json
-github.com/gorilla/mux
-golang.org/x/net/html
-</pre>
-<p>
-The -f flag specifies an alternate format for the list, using the
-syntax of package template.  The default output is equivalent to -f
-&#39;&#39;. The struct being passed to the template is:
-</p>
-<pre>type Package struct {
-    Dir           string // directory containing package sources
-    ImportPath    string // import path of package in dir
-    ImportComment string // path in import comment on package statement
-    Name          string // package name
-    Doc           string // package documentation string
-    Target        string // install path
-    Shlib         string // the shared library that contains this package (only set when -linkshared)
-    Goroot        bool   // is this package in the Go root?
-    Standard      bool   // is this package part of the standard Go library?
-    Stale         bool   // would &#39;go install&#39; do anything for this package?
-    StaleReason   string // explanation for Stale==true
-    Root          string // Go root or Go path dir containing this package
-    ConflictDir   string // this directory shadows Dir in $GOPATH
-    BinaryOnly    bool   // binary-only package: cannot be recompiled from sources
-
-    // Source files
-    GoFiles        []string // .go source files (excluding CgoFiles, TestGoFiles, XTestGoFiles)
-    CgoFiles       []string // .go sources files that import &#34;C&#34;
-    IgnoredGoFiles []string // .go sources ignored due to build constraints
-    CFiles         []string // .c source files
-    CXXFiles       []string // .cc, .cxx and .cpp source files
-    MFiles         []string // .m source files
-    HFiles         []string // .h, .hh, .hpp and .hxx source files
-    FFiles         []string // .f, .F, .for and .f90 Fortran source files
-    SFiles         []string // .s source files
-    SwigFiles      []string // .swig files
-    SwigCXXFiles   []string // .swigcxx files
-    SysoFiles      []string // .syso object files to add to archive
-    TestGoFiles    []string // _test.go files in package
-    XTestGoFiles   []string // _test.go files outside package
-
-    // Cgo directives
-    CgoCFLAGS    []string // cgo: flags for C compiler
-    CgoCPPFLAGS  []string // cgo: flags for C preprocessor
-    CgoCXXFLAGS  []string // cgo: flags for C++ compiler
-    CgoFFLAGS    []string // cgo: flags for Fortran compiler
-    CgoLDFLAGS   []string // cgo: flags for linker
-    CgoPkgConfig []string // cgo: pkg-config names
-
-    // Dependency information
-    Imports      []string // import paths used by this package
-    Deps         []string // all (recursively) imported dependencies
-    TestImports  []string // imports from TestGoFiles
-    XTestImports []string // imports from XTestGoFiles
-
-    // Error information
-    Incomplete bool            // this package or a dependency has an error
-    Error      *PackageError   // error loading package
-    DepsErrors []*PackageError // errors loading dependencies
-}
-</pre>
-<p>
-Packages stored in vendor directories report an ImportPath that includes the
-path to the vendor directory (for example, &#34;d/vendor/p&#34; instead of &#34;p&#34;),
-so that the ImportPath uniquely identifies a given copy of a package.
-The Imports, Deps, TestImports, and XTestImports lists also contain these
-expanded imports paths. See golang.org/s/go15vendor for more about vendoring.
-</p>
-<p>
-The error information, if any, is
-</p>
-<pre>type PackageError struct {
-    ImportStack   []string // shortest path from package named on command line to this one
-    Pos           string   // position of error (if present, file:line:col)
-    Err           string   // the error itself
-}
-</pre>
-<p>
-The template function &#34;join&#34; calls strings.Join.
-</p>
-<p>
-The template function &#34;context&#34; returns the build context, defined as:
-</p>
-<pre>type Context struct {
-	GOARCH        string   // target architecture
-	GOOS          string   // target operating system
-	GOROOT        string   // Go root
-	GOPATH        string   // Go path
-	CgoEnabled    bool     // whether cgo can be used
-	UseAllFiles   bool     // use files regardless of +build lines, file names
-	Compiler      string   // compiler to assume when computing target paths
-	BuildTags     []string // build constraints to match in +build lines
-	ReleaseTags   []string // releases the current release is compatible with
-	InstallSuffix string   // suffix to use in the name of the install dir
-}
-</pre>
-<p>
-For more information about the meaning of these fields see the documentation
-for the go/build package&#39;s Context type.
-</p>
-<p>
-The -json flag causes the package data to be printed in JSON format
-instead of using the template format.
-</p>
-<p>
-The -e flag changes the handling of erroneous packages, those that
-cannot be found or are malformed.  By default, the list command
-prints an error to standard error for each erroneous package and
-omits the packages from consideration during the usual printing.
-With the -e flag, the list command never prints errors to standard
-error and instead processes the erroneous packages with the usual
-printing.  Erroneous packages will have a non-empty ImportPath and
-a non-nil Error field; other information may or may not be missing
-(zeroed).
-</p>
-<p>
-For more about build flags, see &#39;go help build&#39;.
-</p>
-<p>
-For more about specifying packages, see &#39;go help packages&#39;.
-</p>
-<h3 id="hdr-Compile_and_run_Go_program">Compile and run Go program</h3>
-<p>
-Usage:
-</p>
-<pre>go run [build flags] [-exec xprog] gofiles... [arguments...]
-</pre>
-<p>
-Run compiles and runs the main package comprising the named Go source files.
-A Go source file is defined to be a file ending in a literal &#34;.go&#34; suffix.
-</p>
-<p>
-By default, &#39;go run&#39; runs the compiled binary directly: &#39;a.out arguments...&#39;.
-If the -exec flag is given, &#39;go run&#39; invokes the binary using xprog:
-</p>
-<pre>&#39;xprog a.out arguments...&#39;.
-</pre>
-<p>
-If the -exec flag is not given, GOOS or GOARCH is different from the system
-default, and a program named go_$GOOS_$GOARCH_exec can be found
-on the current search path, &#39;go run&#39; invokes the binary using that program,
-for example &#39;go_nacl_386_exec a.out arguments...&#39;. This allows execution of
-cross-compiled programs when a simulator or other execution method is
-available.
-</p>
-<p>
-For more about build flags, see &#39;go help build&#39;.
-</p>
-<p>
-See also: go build.
-</p>
-<h3 id="hdr-Test_packages">Test packages</h3>
-<p>
-Usage:
-</p>
-<pre>go test [build/test flags] [packages] [build/test flags &amp; test binary flags]
-</pre>
-<p>
-&#39;Go test&#39; automates testing the packages named by the import paths.
-It prints a summary of the test results in the format:
-</p>
-<pre>ok   archive/tar   0.011s
-FAIL archive/zip   0.022s
-ok   compress/gzip 0.033s
-...
-</pre>
-<p>
-followed by detailed output for each failed package.
-</p>
-<p>
-&#39;Go test&#39; recompiles each package along with any files with names matching
-the file pattern &#34;*_test.go&#34;.
-Files whose names begin with &#34;_&#34; (including &#34;_test.go&#34;) or &#34;.&#34; are ignored.
-These additional files can contain test functions, benchmark functions, and
-example functions.  See &#39;go help testfunc&#39; for more.
-Each listed package causes the execution of a separate test binary.
-</p>
-<p>
-Test files that declare a package with the suffix &#34;_test&#34; will be compiled as a
-separate package, and then linked and run with the main test binary.
-</p>
-<p>
-The go tool will ignore a directory named &#34;testdata&#34;, making it available
-to hold ancillary data needed by the tests.
-</p>
-<p>
-By default, go test needs no arguments.  It compiles and tests the package
-with source in the current directory, including tests, and runs the tests.
-</p>
-<p>
-The package is built in a temporary directory so it does not interfere with the
-non-test installation.
-</p>
-<p>
-In addition to the build flags, the flags handled by &#39;go test&#39; itself are:
-</p>
-<pre>-args
-    Pass the remainder of the command line (everything after -args)
-    to the test binary, uninterpreted and unchanged.
-    Because this flag consumes the remainder of the command line,
-    the package list (if present) must appear before this flag.
-
--c
-    Compile the test binary to pkg.test but do not run it
-    (where pkg is the last element of the package&#39;s import path).
-    The file name can be changed with the -o flag.
-
--exec xprog
-    Run the test binary using xprog. The behavior is the same as
-    in &#39;go run&#39;. See &#39;go help run&#39; for details.
-
--i
-    Install packages that are dependencies of the test.
-    Do not run the test.
-
--o file
-    Compile the test binary to the named file.
-    The test still runs (unless -c or -i is specified).
-</pre>
-<p>
-The test binary also accepts flags that control execution of the test; these
-flags are also accessible by &#39;go test&#39;. See &#39;go help testflag&#39; for details.
-</p>
-<p>
-For more about build flags, see &#39;go help build&#39;.
-For more about specifying packages, see &#39;go help packages&#39;.
-</p>
-<p>
-See also: go build, go vet.
-</p>
-<h3 id="hdr-Run_specified_go_tool">Run specified go tool</h3>
-<p>
-Usage:
-</p>
-<pre>go tool [-n] command [args...]
-</pre>
-<p>
-Tool runs the go tool command identified by the arguments.
-With no arguments it prints the list of known tools.
-</p>
-<p>
-The -n flag causes tool to print the command that would be
-executed but not execute it.
-</p>
-<p>
-For more about each tool command, see &#39;go tool command -h&#39;.
-</p>
-<h3 id="hdr-Print_Go_version">Print Go version</h3>
-<p>
-Usage:
-</p>
-<pre>go version
-</pre>
-<p>
-Version prints the Go version, as reported by runtime.Version.
-</p>
-<h3 id="hdr-Run_go_tool_vet_on_packages">Run go tool vet on packages</h3>
-<p>
-Usage:
-</p>
-<pre>go vet [-n] [-x] [build flags] [packages]
-</pre>
-<p>
-Vet runs the Go vet command on the packages named by the import paths.
-</p>
-<p>
-For more about vet, see &#39;go doc cmd/vet&#39;.
-For more about specifying packages, see &#39;go help packages&#39;.
-</p>
-<p>
-To run the vet tool with specific options, run &#39;go tool vet&#39;.
-</p>
-<p>
-The -n flag prints commands that would be executed.
-The -x flag prints commands as they are executed.
-</p>
-<p>
-For more about build flags, see &#39;go help build&#39;.
-</p>
-<p>
-See also: go fmt, go fix.
-</p>
-<h3 id="hdr-Calling_between_Go_and_C">Calling between Go and C</h3>
-<p>
-There are two different ways to call between Go and C/C++ code.
-</p>
-<p>
-The first is the cgo tool, which is part of the Go distribution.  For
-information on how to use it see the cgo documentation (go doc cmd/cgo).
-</p>
-<p>
-The second is the SWIG program, which is a general tool for
-interfacing between languages.  For information on SWIG see
-<a href="http://swig.org/">http://swig.org/</a>.  When running go build, any file with a .swig
-extension will be passed to SWIG.  Any file with a .swigcxx extension
-will be passed to SWIG with the -c++ option.
-</p>
-<p>
-When either cgo or SWIG is used, go build will pass any .c, .m, .s,
-or .S files to the C compiler, and any .cc, .cpp, .cxx files to the C++
-compiler.  The CC or CXX environment variables may be set to determine
-the C or C++ compiler, respectively, to use.
-</p>
-<h3 id="hdr-Description_of_build_modes">Description of build modes</h3>
-<p>
-The &#39;go build&#39; and &#39;go install&#39; commands take a -buildmode argument which
-indicates which kind of object file is to be built. Currently supported values
-are:
-</p>
-<pre>-buildmode=archive
-	Build the listed non-main packages into .a files. Packages named
-	main are ignored.
-
--buildmode=c-archive
-	Build the listed main package, plus all packages it imports,
-	into a C archive file. The only callable symbols will be those
-	functions exported using a cgo //export comment. Requires
-	exactly one main package to be listed.
-
--buildmode=c-shared
-	Build the listed main packages, plus all packages that they
-	import, into C shared libraries. The only callable symbols will
-	be those functions exported using a cgo //export comment.
-	Non-main packages are ignored.
-
--buildmode=default
-	Listed main packages are built into executables and listed
-	non-main packages are built into .a files (the default
-	behavior).
-
--buildmode=shared
-	Combine all the listed non-main packages into a single shared
-	library that will be used when building with the -linkshared
-	option. Packages named main are ignored.
-
--buildmode=exe
-	Build the listed main packages and everything they import into
-	executables. Packages not named main are ignored.
-
--buildmode=pie
-	Build the listed main packages and everything they import into
-	position independent executables (PIE). Packages not named
-	main are ignored.
-
--buildmode=plugin
-	Build the listed main packages, plus all packages that they
-	import, into a Go plugin. Packages not named main are ignored.
-</pre>
-<h3 id="hdr-File_types">File types</h3>
-<p>
-The go command examines the contents of a restricted set of files
-in each directory. It identifies which files to examine based on
-the extension of the file name. These extensions are:
-</p>
-<pre>.go
-	Go source files.
-.c, .h
-	C source files.
-	If the package uses cgo or SWIG, these will be compiled with the
-	OS-native compiler (typically gcc); otherwise they will
-	trigger an error.
-.cc, .cpp, .cxx, .hh, .hpp, .hxx
-	C++ source files. Only useful with cgo or SWIG, and always
-	compiled with the OS-native compiler.
-.m
-	Objective-C source files. Only useful with cgo, and always
-	compiled with the OS-native compiler.
-.s, .S
-	Assembler source files.
-	If the package uses cgo or SWIG, these will be assembled with the
-	OS-native assembler (typically gcc (sic)); otherwise they
-	will be assembled with the Go assembler.
-.swig, .swigcxx
-	SWIG definition files.
-.syso
-	System object files.
-</pre>
-<p>
-Files of each of these types except .syso may contain build
-constraints, but the go command stops scanning for build constraints
-at the first item in the file that is not a blank line or //-style
-line comment. See the go/build package documentation for
-more details.
-</p>
-<p>
-Non-test Go source files can also include a //go:binary-only-package
-comment, indicating that the package sources are included
-for documentation only and must not be used to build the
-package binary. This enables distribution of Go packages in
-their compiled form alone. See the go/build package documentation
-for more details.
-</p>
-<h3 id="hdr-GOPATH_environment_variable">GOPATH environment variable</h3>
-<p>
-The Go path is used to resolve import statements.
-It is implemented by and documented in the go/build package.
-</p>
-<p>
-The GOPATH environment variable lists places to look for Go code.
-On Unix, the value is a colon-separated string.
-On Windows, the value is a semicolon-separated string.
-On Plan 9, the value is a list.
-</p>
-<p>
-If the environment variable is unset, GOPATH defaults
-to a subdirectory named &#34;go&#34; in the user&#39;s home directory
-($HOME/go on Unix, %USERPROFILE%\go on Windows),
-unless that directory holds a Go distribution.
-Run &#34;go env GOPATH&#34; to see the current GOPATH.
-</p>
-<p>
-See <a href="https://golang.org/wiki/SettingGOPATH">https://golang.org/wiki/SettingGOPATH</a> to set a custom GOPATH.
-</p>
-<p>
-Each directory listed in GOPATH must have a prescribed structure:
-</p>
-<p>
-The src directory holds source code.  The path below src
-determines the import path or executable name.
-</p>
-<p>
-The pkg directory holds installed package objects.
-As in the Go tree, each target operating system and
-architecture pair has its own subdirectory of pkg
-(pkg/GOOS_GOARCH).
-</p>
-<p>
-If DIR is a directory listed in the GOPATH, a package with
-source in DIR/src/foo/bar can be imported as &#34;foo/bar&#34; and
-has its compiled form installed to &#34;DIR/pkg/GOOS_GOARCH/foo/bar.a&#34;.
-</p>
-<p>
-The bin directory holds compiled commands.
-Each command is named for its source directory, but only
-the final element, not the entire path.  That is, the
-command with source in DIR/src/foo/quux is installed into
-DIR/bin/quux, not DIR/bin/foo/quux.  The &#34;foo/&#34; prefix is stripped
-so that you can add DIR/bin to your PATH to get at the
-installed commands.  If the GOBIN environment variable is
-set, commands are installed to the directory it names instead
-of DIR/bin. GOBIN must be an absolute path.
-</p>
-<p>
-Here&#39;s an example directory layout:
-</p>
-<pre>GOPATH=/home/user/go
-
-/home/user/go/
-    src/
-        foo/
-            bar/               (go code in package bar)
-                x.go
-            quux/              (go code in package main)
-                y.go
-    bin/
-        quux                   (installed command)
-    pkg/
-        linux_amd64/
-            foo/
-                bar.a          (installed package object)
-</pre>
-<p>
-Go searches each directory listed in GOPATH to find source code,
-but new packages are always downloaded into the first directory
-in the list.
-</p>
-<p>
-See <a href="https://golang.org/doc/code.html">https://golang.org/doc/code.html</a> for an example.
-</p>
-<h3 id="hdr-Internal_Directories">Internal Directories</h3>
-<p>
-Code in or below a directory named &#34;internal&#34; is importable only
-by code in the directory tree rooted at the parent of &#34;internal&#34;.
-Here&#39;s an extended version of the directory layout above:
-</p>
-<pre>/home/user/go/
-    src/
-        crash/
-            bang/              (go code in package bang)
-                b.go
-        foo/                   (go code in package foo)
-            f.go
-            bar/               (go code in package bar)
-                x.go
-            internal/
-                baz/           (go code in package baz)
-                    z.go
-            quux/              (go code in package main)
-                y.go
-</pre>
-<p>
-The code in z.go is imported as &#34;foo/internal/baz&#34;, but that
-import statement can only appear in source files in the subtree
-rooted at foo. The source files foo/f.go, foo/bar/x.go, and
-foo/quux/y.go can all import &#34;foo/internal/baz&#34;, but the source file
-crash/bang/b.go cannot.
-</p>
-<p>
-See <a href="https://golang.org/s/go14internal">https://golang.org/s/go14internal</a> for details.
-</p>
-<h3 id="hdr-Vendor_Directories">Vendor Directories</h3>
-<p>
-Go 1.6 includes support for using local copies of external dependencies
-to satisfy imports of those dependencies, often referred to as vendoring.
-</p>
-<p>
-Code below a directory named &#34;vendor&#34; is importable only
-by code in the directory tree rooted at the parent of &#34;vendor&#34;,
-and only using an import path that omits the prefix up to and
-including the vendor element.
-</p>
-<p>
-Here&#39;s the example from the previous section,
-but with the &#34;internal&#34; directory renamed to &#34;vendor&#34;
-and a new foo/vendor/crash/bang directory added:
-</p>
-<pre>/home/user/go/
-    src/
-        crash/
-            bang/              (go code in package bang)
-                b.go
-        foo/                   (go code in package foo)
-            f.go
-            bar/               (go code in package bar)
-                x.go
-            vendor/
-                crash/
-                    bang/      (go code in package bang)
-                        b.go
-                baz/           (go code in package baz)
-                    z.go
-            quux/              (go code in package main)
-                y.go
-</pre>
-<p>
-The same visibility rules apply as for internal, but the code
-in z.go is imported as &#34;baz&#34;, not as &#34;foo/vendor/baz&#34;.
-</p>
-<p>
-Code in vendor directories deeper in the source tree shadows
-code in higher directories. Within the subtree rooted at foo, an import
-of &#34;crash/bang&#34; resolves to &#34;foo/vendor/crash/bang&#34;, not the
-top-level &#34;crash/bang&#34;.
-</p>
-<p>
-Code in vendor directories is not subject to import path
-checking (see &#39;go help importpath&#39;).
-</p>
-<p>
-When &#39;go get&#39; checks out or updates a git repository, it now also
-updates submodules.
-</p>
-<p>
-Vendor directories do not affect the placement of new repositories
-being checked out for the first time by &#39;go get&#39;: those are always
-placed in the main GOPATH, never in a vendor subtree.
-</p>
-<p>
-See <a href="https://golang.org/s/go15vendor">https://golang.org/s/go15vendor</a> for details.
-</p>
-<h3 id="hdr-Environment_variables">Environment variables</h3>
-<p>
-The go command, and the tools it invokes, examine a few different
-environment variables. For many of these, you can see the default
-value of on your system by running &#39;go env NAME&#39;, where NAME is the
-name of the variable.
-</p>
-<p>
-General-purpose environment variables:
-</p>
-<pre>GCCGO
-	The gccgo command to run for &#39;go build -compiler=gccgo&#39;.
-GOARCH
-	The architecture, or processor, for which to compile code.
-	Examples are amd64, 386, arm, ppc64.
-GOBIN
-	The directory where &#39;go install&#39; will install a command.
-GOOS
-	The operating system for which to compile code.
-	Examples are linux, darwin, windows, netbsd.
-GOPATH
-	For more details see: &#39;go help gopath&#39;.
-GORACE
-	Options for the race detector.
-	See <a href="https://golang.org/doc/articles/race_detector.html">https://golang.org/doc/articles/race_detector.html</a>.
-GOROOT
-	The root of the go tree.
-</pre>
-<p>
-Environment variables for use with cgo:
-</p>
-<pre>CC
-	The command to use to compile C code.
-CGO_ENABLED
-	Whether the cgo command is supported.  Either 0 or 1.
-CGO_CFLAGS
-	Flags that cgo will pass to the compiler when compiling
-	C code.
-CGO_CPPFLAGS
-	Flags that cgo will pass to the compiler when compiling
-	C or C++ code.
-CGO_CXXFLAGS
-	Flags that cgo will pass to the compiler when compiling
-	C++ code.
-CGO_FFLAGS
-	Flags that cgo will pass to the compiler when compiling
-	Fortran code.
-CGO_LDFLAGS
-	Flags that cgo will pass to the compiler when linking.
-CXX
-	The command to use to compile C++ code.
-PKG_CONFIG
-	Path to pkg-config tool.
-</pre>
-<p>
-Architecture-specific environment variables:
-</p>
-<pre>GOARM
-	For GOARCH=arm, the ARM architecture for which to compile.
-	Valid values are 5, 6, 7.
-GO386
-	For GOARCH=386, the floating point instruction set.
-	Valid values are 387, sse2.
-</pre>
-<p>
-Special-purpose environment variables:
-</p>
-<pre>GOROOT_FINAL
-	The root of the installed Go tree, when it is
-	installed in a location other than where it is built.
-	File names in stack traces are rewritten from GOROOT to
-	GOROOT_FINAL.
-GO_EXTLINK_ENABLED
-	Whether the linker should use external linking mode
-	when using -linkmode=auto with code that uses cgo.
-	Set to 0 to disable external linking mode, 1 to enable it.
-GIT_ALLOW_PROTOCOL
-	Defined by Git. A colon-separated list of schemes that are allowed to be used
-	with git fetch/clone. If set, any scheme not explicitly mentioned will be
-	considered insecure by &#39;go get&#39;.
-</pre>
-<h3 id="hdr-Import_path_syntax">Import path syntax</h3>
-<p>
-An import path (see &#39;go help packages&#39;) denotes a package stored in the local
-file system.  In general, an import path denotes either a standard package (such
-as &#34;unicode/utf8&#34;) or a package found in one of the work spaces (For more
-details see: &#39;go help gopath&#39;).
-</p>
-<h3 id="hdr-Relative_import_paths">Relative import paths</h3>
-<p>
-An import path beginning with ./ or ../ is called a relative path.
-The toolchain supports relative import paths as a shortcut in two ways.
-</p>
-<p>
-First, a relative path can be used as a shorthand on the command line.
-If you are working in the directory containing the code imported as
-&#34;unicode&#34; and want to run the tests for &#34;unicode/utf8&#34;, you can type
-&#34;go test ./utf8&#34; instead of needing to specify the full path.
-Similarly, in the reverse situation, &#34;go test ..&#34; will test &#34;unicode&#34; from
-the &#34;unicode/utf8&#34; directory. Relative patterns are also allowed, like
-&#34;go test ./...&#34; to test all subdirectories. See &#39;go help packages&#39; for details
-on the pattern syntax.
-</p>
-<p>
-Second, if you are compiling a Go program not in a work space,
-you can use a relative path in an import statement in that program
-to refer to nearby code also not in a work space.
-This makes it easy to experiment with small multipackage programs
-outside of the usual work spaces, but such programs cannot be
-installed with &#34;go install&#34; (there is no work space in which to install them),
-so they are rebuilt from scratch each time they are built.
-To avoid ambiguity, Go programs cannot use relative import paths
-within a work space.
-</p>
-<h3 id="hdr-Remote_import_paths">Remote import paths</h3>
-<p>
-Certain import paths also
-describe how to obtain the source code for the package using
-a revision control system.
-</p>
-<p>
-A few common code hosting sites have special syntax:
-</p>
-<pre>Bitbucket (Git, Mercurial)
-
-	import &#34;bitbucket.org/user/project&#34;
-	import &#34;bitbucket.org/user/project/sub/directory&#34;
-
-GitHub (Git)
-
-	import &#34;github.com/user/project&#34;
-	import &#34;github.com/user/project/sub/directory&#34;
-
-Launchpad (Bazaar)
-
-	import &#34;launchpad.net/project&#34;
-	import &#34;launchpad.net/project/series&#34;
-	import &#34;launchpad.net/project/series/sub/directory&#34;
-
-	import &#34;launchpad.net/~user/project/branch&#34;
-	import &#34;launchpad.net/~user/project/branch/sub/directory&#34;
-
-IBM DevOps Services (Git)
-
-	import &#34;hub.jazz.net/git/user/project&#34;
-	import &#34;hub.jazz.net/git/user/project/sub/directory&#34;
-</pre>
-<p>
-For code hosted on other servers, import paths may either be qualified
-with the version control type, or the go tool can dynamically fetch
-the import path over https/http and discover where the code resides
-from a &lt;meta&gt; tag in the HTML.
-</p>
-<p>
-To declare the code location, an import path of the form
-</p>
-<pre>repository.vcs/path
-</pre>
-<p>
-specifies the given repository, with or without the .vcs suffix,
-using the named version control system, and then the path inside
-that repository.  The supported version control systems are:
-</p>
-<pre>Bazaar      .bzr
-Git         .git
-Mercurial   .hg
-Subversion  .svn
-</pre>
-<p>
-For example,
-</p>
-<pre>import &#34;example.org/user/foo.hg&#34;
-</pre>
-<p>
-denotes the root directory of the Mercurial repository at
-example.org/user/foo or foo.hg, and
-</p>
-<pre>import &#34;example.org/repo.git/foo/bar&#34;
-</pre>
-<p>
-denotes the foo/bar directory of the Git repository at
-example.org/repo or repo.git.
-</p>
-<p>
-When a version control system supports multiple protocols,
-each is tried in turn when downloading.  For example, a Git
-download tries https://, then git+ssh://.
-</p>
-<p>
-By default, downloads are restricted to known secure protocols
-(e.g. https, ssh). To override this setting for Git downloads, the
-GIT_ALLOW_PROTOCOL environment variable can be set (For more details see:
-&#39;go help environment&#39;).
-</p>
-<p>
-If the import path is not a known code hosting site and also lacks a
-version control qualifier, the go tool attempts to fetch the import
-over https/http and looks for a &lt;meta&gt; tag in the document&#39;s HTML
-&lt;head&gt;.
-</p>
-<p>
-The meta tag has the form:
-</p>
-<pre>&lt;meta name=&#34;go-import&#34; content=&#34;import-prefix vcs repo-root&#34;&gt;
-</pre>
-<p>
-The import-prefix is the import path corresponding to the repository
-root. It must be a prefix or an exact match of the package being
-fetched with &#34;go get&#34;. If it&#39;s not an exact match, another http
-request is made at the prefix to verify the &lt;meta&gt; tags match.
-</p>
-<p>
-The meta tag should appear as early in the file as possible.
-In particular, it should appear before any raw JavaScript or CSS,
-to avoid confusing the go command&#39;s restricted parser.
-</p>
-<p>
-The vcs is one of &#34;git&#34;, &#34;hg&#34;, &#34;svn&#34;, etc,
-</p>
-<p>
-The repo-root is the root of the version control system
-containing a scheme and not containing a .vcs qualifier.
-</p>
-<p>
-For example,
-</p>
-<pre>import &#34;example.org/pkg/foo&#34;
-</pre>
-<p>
-will result in the following requests:
-</p>
-<pre><a href="https://example.org/pkg/foo?go-get=1">https://example.org/pkg/foo?go-get=1</a> (preferred)
-<a href="http://example.org/pkg/foo?go-get=1">http://example.org/pkg/foo?go-get=1</a>  (fallback, only with -insecure)
-</pre>
-<p>
-If that page contains the meta tag
-</p>
-<pre>&lt;meta name=&#34;go-import&#34; content=&#34;example.org git <a href="https://code.org/r/p/exproj">https://code.org/r/p/exproj</a>&#34;&gt;
-</pre>
-<p>
-the go tool will verify that <a href="https://example.org/?go-get=1">https://example.org/?go-get=1</a> contains the
-same meta tag and then git clone <a href="https://code.org/r/p/exproj">https://code.org/r/p/exproj</a> into
-GOPATH/src/example.org.
-</p>
-<p>
-New downloaded packages are written to the first directory listed in the GOPATH
-environment variable (For more details see: &#39;go help gopath&#39;).
-</p>
-<p>
-The go command attempts to download the version of the
-package appropriate for the Go release being used.
-Run &#39;go help get&#39; for more.
-</p>
-<h3 id="hdr-Import_path_checking">Import path checking</h3>
-<p>
-When the custom import path feature described above redirects to a
-known code hosting site, each of the resulting packages has two possible
-import paths, using the custom domain or the known hosting site.
-</p>
-<p>
-A package statement is said to have an &#34;import comment&#34; if it is immediately
-followed (before the next newline) by a comment of one of these two forms:
-</p>
-<pre>package math // import &#34;path&#34;
-package math /* import &#34;path&#34; */
-</pre>
-<p>
-The go command will refuse to install a package with an import comment
-unless it is being referred to by that import path. In this way, import comments
-let package authors make sure the custom import path is used and not a
-direct path to the underlying code hosting site.
-</p>
-<p>
-Import path checking is disabled for code found within vendor trees.
-This makes it possible to copy code into alternate locations in vendor trees
-without needing to update import comments.
-</p>
-<p>
-See <a href="https://golang.org/s/go14customimport">https://golang.org/s/go14customimport</a> for details.
-</p>
-<h3 id="hdr-Description_of_package_lists">Description of package lists</h3>
-<p>
-Many commands apply to a set of packages:
-</p>
-<pre>go action [packages]
-</pre>
-<p>
-Usually, [packages] is a list of import paths.
-</p>
-<p>
-An import path that is a rooted path or that begins with
-a . or .. element is interpreted as a file system path and
-denotes the package in that directory.
-</p>
-<p>
-Otherwise, the import path P denotes the package found in
-the directory DIR/src/P for some DIR listed in the GOPATH
-environment variable (For more details see: &#39;go help gopath&#39;).
-</p>
-<p>
-If no import paths are given, the action applies to the
-package in the current directory.
-</p>
-<p>
-There are four reserved names for paths that should not be used
-for packages to be built with the go tool:
-</p>
-<p>
-- &#34;main&#34; denotes the top-level package in a stand-alone executable.
-</p>
-<p>
-- &#34;all&#34; expands to all package directories found in all the GOPATH
-trees. For example, &#39;go list all&#39; lists all the packages on the local
-system.
-</p>
-<p>
-- &#34;std&#34; is like all but expands to just the packages in the standard
-Go library.
-</p>
-<p>
-- &#34;cmd&#34; expands to the Go repository&#39;s commands and their
-internal libraries.
-</p>
-<p>
-Import paths beginning with &#34;cmd/&#34; only match source code in
-the Go repository.
-</p>
-<p>
-An import path is a pattern if it includes one or more &#34;...&#34; wildcards,
-each of which can match any string, including the empty string and
-strings containing slashes.  Such a pattern expands to all package
-directories found in the GOPATH trees with names matching the
-patterns.  As a special case, x/... matches x as well as x&#39;s subdirectories.
-For example, net/... expands to net and packages in its subdirectories.
-</p>
-<p>
-An import path can also name a package to be downloaded from
-a remote repository.  Run &#39;go help importpath&#39; for details.
-</p>
-<p>
-Every package in a program must have a unique import path.
-By convention, this is arranged by starting each path with a
-unique prefix that belongs to you.  For example, paths used
-internally at Google all begin with &#39;google&#39;, and paths
-denoting remote repositories begin with the path to the code,
-such as &#39;github.com/user/repo&#39;.
-</p>
-<p>
-Packages in a program need not have unique package names,
-but there are two reserved package names with special meaning.
-The name main indicates a command, not a library.
-Commands are built into binaries and cannot be imported.
-The name documentation indicates documentation for
-a non-Go program in the directory. Files in package documentation
-are ignored by the go command.
-</p>
-<p>
-As a special case, if the package list is a list of .go files from a
-single directory, the command is applied to a single synthesized
-package made up of exactly those files, ignoring any build constraints
-in those files and ignoring any other files in the directory.
-</p>
-<p>
-Directory and file names that begin with &#34;.&#34; or &#34;_&#34; are ignored
-by the go tool, as are directories named &#34;testdata&#34;.
-</p>
-<h3 id="hdr-Description_of_testing_flags">Description of testing flags</h3>
-<p>
-The &#39;go test&#39; command takes both flags that apply to &#39;go test&#39; itself
-and flags that apply to the resulting test binary.
-</p>
-<p>
-Several of the flags control profiling and write an execution profile
-suitable for &#34;go tool pprof&#34;; run &#34;go tool pprof -h&#34; for more
-information.  The --alloc_space, --alloc_objects, and --show_bytes
-options of pprof control how the information is presented.
-</p>
-<p>
-The following flags are recognized by the &#39;go test&#39; command and
-control the execution of any test:
-</p>
-<pre>-bench regexp
-    Run (sub)benchmarks matching a regular expression.
-    The given regular expression is split into smaller ones by
-    top-level &#39;/&#39;, where each must match the corresponding part of a
-    benchmark&#39;s identifier.
-    By default, no benchmarks run. To run all benchmarks,
-    use &#39;-bench .&#39; or &#39;-bench=.&#39;.
-
--benchtime t
-    Run enough iterations of each benchmark to take t, specified
-    as a time.Duration (for example, -benchtime 1h30s).
-    The default is 1 second (1s).
-
--count n
-    Run each test and benchmark n times (default 1).
-    If -cpu is set, run n times for each GOMAXPROCS value.
-    Examples are always run once.
-
--cover
-    Enable coverage analysis.
-
--covermode set,count,atomic
-    Set the mode for coverage analysis for the package[s]
-    being tested. The default is &#34;set&#34; unless -race is enabled,
-    in which case it is &#34;atomic&#34;.
-    The values:
-	set: bool: does this statement run?
-	count: int: how many times does this statement run?
-	atomic: int: count, but correct in multithreaded tests;
-		significantly more expensive.
-    Sets -cover.
-
--coverpkg pkg1,pkg2,pkg3
-    Apply coverage analysis in each test to the given list of packages.
-    The default is for each test to analyze only the package being tested.
-    Packages are specified as import paths.
-    Sets -cover.
-
--cpu 1,2,4
-    Specify a list of GOMAXPROCS values for which the tests or
-    benchmarks should be executed.  The default is the current value
-    of GOMAXPROCS.
-
--parallel n
-    Allow parallel execution of test functions that call t.Parallel.
-    The value of this flag is the maximum number of tests to run
-    simultaneously; by default, it is set to the value of GOMAXPROCS.
-    Note that -parallel only applies within a single test binary.
-    The &#39;go test&#39; command may run tests for different packages
-    in parallel as well, according to the setting of the -p flag
-    (see &#39;go help build&#39;).
-
--run regexp
-    Run only those tests and examples matching the regular expression.
-    For tests the regular expression is split into smaller ones by
-    top-level &#39;/&#39;, where each must match the corresponding part of a
-    test&#39;s identifier.
-
--short
-    Tell long-running tests to shorten their run time.
-    It is off by default but set during all.bash so that installing
-    the Go tree can run a sanity check but not spend time running
-    exhaustive tests.
-
--timeout t
-    If a test runs longer than t, panic.
-    The default is 10 minutes (10m).
-
--v
-    Verbose output: log all tests as they are run. Also print all
-    text from Log and Logf calls even if the test succeeds.
-</pre>
-<p>
-The following flags are also recognized by &#39;go test&#39; and can be used to
-profile the tests during execution:
-</p>
-<pre>-benchmem
-    Print memory allocation statistics for benchmarks.
-
--blockprofile block.out
-    Write a goroutine blocking profile to the specified file
-    when all tests are complete.
-    Writes test binary as -c would.
-
--blockprofilerate n
-    Control the detail provided in goroutine blocking profiles by
-    calling runtime.SetBlockProfileRate with n.
-    See &#39;go doc runtime.SetBlockProfileRate&#39;.
-    The profiler aims to sample, on average, one blocking event every
-    n nanoseconds the program spends blocked.  By default,
-    if -test.blockprofile is set without this flag, all blocking events
-    are recorded, equivalent to -test.blockprofilerate=1.
-
--coverprofile cover.out
-    Write a coverage profile to the file after all tests have passed.
-    Sets -cover.
-
--cpuprofile cpu.out
-    Write a CPU profile to the specified file before exiting.
-    Writes test binary as -c would.
-
--memprofile mem.out
-    Write a memory profile to the file after all tests have passed.
-    Writes test binary as -c would.
-
--memprofilerate n
-    Enable more precise (and expensive) memory profiles by setting
-    runtime.MemProfileRate.  See &#39;go doc runtime.MemProfileRate&#39;.
-    To profile all memory allocations, use -test.memprofilerate=1
-    and pass --alloc_space flag to the pprof tool.
-
--mutexprofile mutex.out
-    Write a mutex contention profile to the specified file
-    when all tests are complete.
-    Writes test binary as -c would.
-
--mutexprofilefraction n
-    Sample 1 in n stack traces of goroutines holding a
-    contended mutex.
-
--outputdir directory
-    Place output files from profiling in the specified directory,
-    by default the directory in which &#34;go test&#34; is running.
-
--trace trace.out
-    Write an execution trace to the specified file before exiting.
-</pre>
-<p>
-Each of these flags is also recognized with an optional &#39;test.&#39; prefix,
-as in -test.v. When invoking the generated test binary (the result of
-&#39;go test -c&#39;) directly, however, the prefix is mandatory.
-</p>
-<p>
-The &#39;go test&#39; command rewrites or removes recognized flags,
-as appropriate, both before and after the optional package list,
-before invoking the test binary.
-</p>
-<p>
-For instance, the command
-</p>
-<pre>go test -v -myflag testdata -cpuprofile=prof.out -x
-</pre>
-<p>
-will compile the test binary and then run it as
-</p>
-<pre>pkg.test -test.v -myflag testdata -test.cpuprofile=prof.out
-</pre>
-<p>
-(The -x flag is removed because it applies only to the go command&#39;s
-execution, not to the test itself.)
-</p>
-<p>
-The test flags that generate profiles (other than for coverage) also
-leave the test binary in pkg.test for use when analyzing the profiles.
-</p>
-<p>
-When &#39;go test&#39; runs a test binary, it does so from within the
-corresponding package&#39;s source code directory. Depending on the test,
-it may be necessary to do the same when invoking a generated test
-binary directly.
-</p>
-<p>
-The command-line package list, if present, must appear before any
-flag not known to the go test command. Continuing the example above,
-the package list would have to appear before -myflag, but could appear
-on either side of -v.
-</p>
-<p>
-To keep an argument for a test binary from being interpreted as a
-known flag or a package name, use -args (see &#39;go help test&#39;) which
-passes the remainder of the command line through to the test binary
-uninterpreted and unaltered.
-</p>
-<p>
-For instance, the command
-</p>
-<pre>go test -v -args -x -v
-</pre>
-<p>
-will compile the test binary and then run it as
-</p>
-<pre>pkg.test -test.v -x -v
-</pre>
-<p>
-Similarly,
-</p>
-<pre>go test -args math
-</pre>
-<p>
-will compile the test binary and then run it as
-</p>
-<pre>pkg.test math
-</pre>
-<p>
-In the first example, the -x and the second -v are passed through to the
-test binary unchanged and with no effect on the go command itself.
-In the second example, the argument math is passed through to the test
-binary, instead of being interpreted as the package list.
-</p>
-<h3 id="hdr-Description_of_testing_functions">Description of testing functions</h3>
-<p>
-The &#39;go test&#39; command expects to find test, benchmark, and example functions
-in the &#34;*_test.go&#34; files corresponding to the package under test.
-</p>
-<p>
-A test function is one named TestXXX (where XXX is any alphanumeric string
-not starting with a lower case letter) and should have the signature,
-</p>
-<pre>func TestXXX(t *testing.T) { ... }
-</pre>
-<p>
-A benchmark function is one named BenchmarkXXX and should have the signature,
-</p>
-<pre>func BenchmarkXXX(b *testing.B) { ... }
-</pre>
-<p>
-An example function is similar to a test function but, instead of using
-*testing.T to report success or failure, prints output to os.Stdout.
-If the last comment in the function starts with &#34;Output:&#34; then the output
-is compared exactly against the comment (see examples below). If the last
-comment begins with &#34;Unordered output:&#34; then the output is compared to the
-comment, however the order of the lines is ignored. An example with no such
-comment is compiled but not executed. An example with no text after
-&#34;Output:&#34; is compiled, executed, and expected to produce no output.
-</p>
-<p>
-Godoc displays the body of ExampleXXX to demonstrate the use
-of the function, constant, or variable XXX.  An example of a method M with
-receiver type T or *T is named ExampleT_M.  There may be multiple examples
-for a given function, constant, or variable, distinguished by a trailing _xxx,
-where xxx is a suffix not beginning with an upper case letter.
-</p>
-<p>
-Here is an example of an example:
-</p>
-<pre>func ExamplePrintln() {
-	Println(&#34;The output of\nthis example.&#34;)
-	// Output: The output of
-	// this example.
-}
-</pre>
-<p>
-Here is another example where the ordering of the output is ignored:
-</p>
-<pre>func ExamplePerm() {
-	for _, value := range Perm(4) {
-		fmt.Println(value)
-	}
-
-	// Unordered output: 4
-	// 2
-	// 1
-	// 3
-	// 0
-}
-</pre>
-<p>
-The entire test file is presented as the example when it contains a single
-example function, at least one other function, type, variable, or constant
-declaration, and no test or benchmark functions.
-</p>
-<p>
-See the documentation of the testing package for more information.
-</p>
-
-<div id="footer">
-Build version go1.8.<br>
-Except as <a href="https://developers.google.com/site-policies#restrictions">noted</a>,
-the content of this page is licensed under the
-Creative Commons Attribution 3.0 License,
-and code is licensed under a <a href="/LICENSE">BSD license</a>.<br>
-<a href="/doc/tos.html">Terms of Service</a> | 
-<a href="http://www.google.com/intl/en/policies/privacy/">Privacy Policy</a>
-</div>
-
-</div><!-- .container -->
-</div><!-- #page -->
-
-<!-- TODO(adonovan): load these from <head> using "defer" attribute? -->
-<script type="text/javascript" src="/serverpush/static/jquery.min.js?{{.CacheBust}}"></script>
-<script type="text/javascript" src="/serverpush/static/playground.js?{{.CacheBust}}"></script>
-<script>var goVersion = "go1.8";</script>
-<script type="text/javascript" src="/serverpush/static/godocs.js?{{.CacheBust}}"></script>
-</body>
-</html>
-`))