go1.4rc2

LGTM=rsc R=rsc CC=golang-codereviews https://golang.org/cl/179700043
[release-branch.go1.4] runtime: fix hang in GC due to shrinkstack vs netpoll race
2026-01-30 23:52:05 +03:00 · 2014-12-02 13:43:43 +11:00 · 2014-12-01 16:42:41 -05:00 · 2014-12-01 11:18:47 -05:00 · 2014-11-26 07:57:03 +11:00 · 2014-11-24 22:00:01 -05:00
6290 changed files with 356279 additions and 1071353 deletions
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,10 +0,0 @@
-# Treat all files in the Go repo as binary, with no git magic updating
-# line endings. Windows users contributing to Go will need to use a
-# modern version of git and editors capable of LF line endings.
-#
-# We'll prevent accidental CRLF line endings from entering the repo
-# via the git-review gofmt checks.
-#
-# See golang.org/issue/9281
-
-* -text
--- a/.github/ISSUE_TEMPLATE
+++ b/.github/ISSUE_TEMPLATE
@@ -1,21 +0,0 @@
-Please answer these questions before submitting your issue. Thanks!
-
-### What version of Go are you using (`go version`)?
-
-
-### What operating system and processor architecture are you using (`go env`)?
-
-
-### What did you do?
-
-If possible, provide a recipe for reproducing the error.
-A complete runnable program is good.
-A link on play.golang.org is best.
-
-
-### What did you expect to see?
-
-
-### What did you see instead?
-
-
--- a/.github/PULL_REQUEST_TEMPLATE
+++ b/.github/PULL_REQUEST_TEMPLATE
@@ -1,7 +0,0 @@
-Please do not send pull requests to the golang/* repositories.
-
-We do, however, take contributions gladly.
-
-See https://golang.org/doc/contribute.html
-
-Thanks!
--- a/.github/SUPPORT
+++ b/.github/SUPPORT
@@ -1,14 +0,0 @@
-Unlike many projects on GitHub, the Go project does not use its bug tracker for general discussion or asking questions.
-We only use our bug tracker for tracking bugs and tracking proposals going through the [Proposal Process](https://golang.org/s/proposal-process).
-
-For asking questions, see:
-
-* [The golang-nuts mailing list](https://groups.google.com/d/forum/golang-nuts)
-
-* [The Go Forum](https://forum.golangbridge.org/), a web-based forum
-
-* [Gophers Slack](https://gophers.slack.com), use the [invite app](https://invite.slack.golangbridge.org/) for access
-
-* [Stack Overflow](http://stackoverflow.com/questions/tagged/go) with questions tagged "go"
-
-* **IRC** channel #go-nuts on Freenode
--- a/.gitignore
+++ b/.gitignore
@@ -1,45 +0,0 @@
-.DS_Store
-*.[56789ao]
-*.a[56789o]
-*.so
-*.pyc
-._*
-.nfs.*
-[56789a].out
-*~
-*.orig
-*.rej
-*.exe
-.*.swp
-core
-*.cgo*.go
-*.cgo*.c
-_cgo_*
-_obj
-_test
-_testmain.go
-
-/VERSION.cache
-/bin/
-/build.out
-/doc/articles/wiki/*.bin
-/goinstall.log
-/last-change
-/misc/cgo/life/run.out
-/misc/cgo/stdio/run.out
-/misc/cgo/testso/main
-/pkg/
-/src/*.*/
-/src/cmd/cgo/zdefaultcc.go
-/src/cmd/go/internal/cfg/zdefaultcc.go
-/src/cmd/go/internal/cfg/zosarch.go
-/src/cmd/internal/objabi/zbootstrap.go
-/src/go/build/zcgo.go
-/src/go/doc/headscan
-/src/runtime/internal/sys/zversion.go
-/src/unicode/maketables
-/test.out
-/test/garbage/*.out
-/test/pass.out
-/test/run.out
-/test/times.out
--- a/.hgignore
+++ b/.hgignore
@@ -0,0 +1,58 @@
+syntax:glob
+.DS_Store
+.git
+.gitignore
+*.[568ao]
+*.a[568o]
+*.so
+*.pyc
+._*
+.nfs.*
+[568a].out
+*~
+*.orig
+*.rej
+*.exe
+.*.swp
+core
+*.cgo*.go
+*.cgo*.c
+_cgo_*
+_obj
+_test
+_testmain.go
+build.out
+test.out
+doc/articles/wiki/*.bin
+include/plan9/libc_plan9.h
+misc/cgo/life/run.out
+misc/cgo/stdio/run.out
+misc/cgo/testso/main
+misc/dashboard/builder/builder
+src/cmd/?a/y.output
+src/liblink/anames?.c
+src/cmd/cc/y.output
+src/cmd/cgo/zdefaultcc.go
+src/cmd/dist/dist.dSYM
+src/cmd/gc/mkbuiltin1
+src/cmd/gc/opnames.h
+src/cmd/gc/y.output
+src/cmd/go/zdefaultcc.go
+src/go/doc/headscan
+src/runtime/mkversion
+src/runtime/z*
+src/unicode/maketables
+src/*.*/
+test/pass.out
+test/run.out
+test/times.out
+test/garbage/*.out
+goinstall.log
+last-change
+VERSION.cache
+
+syntax:regexp
+^bin/
+^pkg/
+^src/cmd/(.*)/6?\1$
+^.*/core.[0-9]*$
--- a/.hgtags
+++ b/.hgtags
@@ -0,0 +1,138 @@
+1f0a01c93d305f1ab636c68b67346659c5b957f7 weekly.2009-11-06
+64e703cb307da550861fe740ff70a482a2c14819 weekly.2009-11-10
+b51fd2d6c16034480f26c96ba32a11c598e4638e weekly.2009-11-10.1
+cb140bac9ab0fd9f734ee443cea9ebadc9c99737 weekly.2009-11-12
+d1b75410b793309532352a6fb6b44453f052f3f4 weekly.2009-11-17
+e205103b02e7393d4719df5faac2dac808234d3f weekly.2009-12-07
+3a47d2e3882bb12129de05382a2c131bb0c00964 weekly.2009-12-09
+a6fcf4303b0a92cce4011556b1c96044252d93af weekly.2009-12-22
+3887d4d81bca78b63d620985d93f1cc06c063871 weekly.2010-01-05
+40dd722155f6d0c83fa572c1a5abf7c6ff35049f weekly.2010-01-13
+0a2770db06efe92b08b5c6f30e14b7e8db012538 weekly.2010-01-27
+db4262ce882d8445764312d41547ee8f11a7f7a9 weekly.2010-02-04
+53fec18b83e2b93baafba4733b59bb86b8c1988e weekly.2010-02-17
+4a0661b86e50eae734dbe43ed1312c4a0304676b weekly.2010-02-23
+a215d03e7ee1013b2abe3f1e2c84457ec51c68e4 weekly.2010-03-04
+194d473264c1a015803d07bed200e0c312aca43e weekly.2010-03-15
+9482fde11a02ffd57ba0561dc8a4ac338061a3ae weekly.2010-03-22
+57380d620ee6b65eb88da1c52784b62c94d7e72e weekly.2010-03-30
+f98f784927abc56a61501eba0cf225966f2b0142 weekly.2010-04-13
+6cc6c0d85fc3234fc0a5ec0a8777aa9d59d05ae8 weekly.2010-04-27
+17ded5ad443b41ac05924864798f1bd8750da344 weekly.2010-05-04
+a85ad0a640154b5d33626ad8ea15ed17e3828178 weekly.2010-05-27
+f776656df34c009f2aad142bf7b34a778404acd1 weekly.2010-06-09
+113ec27f29f18825444f6f8a3cdc156c1df28e87 weekly.2010-06-21
+b761e0299e9bf66298778cf170b0f64216e3cf7d weekly.2010-07-01
+5992bf56aa72efcea87d8dff14985fc8fcc68575 weekly.2010-07-14
+db904d88dc0ebf6ee5b55e44088915695c1223ee weekly.2010-07-29
+8884f7b4c7750481ed246c249db47b61fe752c56 weekly.2010-08-04
+07d3a97302be88af68acff34c8a089589da21d18 weekly.2010-08-11
+18926649cda7498b8aa539b3a611abcff548f09f weekly.2010-08-25
+92fcf05736e8565a485adc52da1894270e06ed09 weekly.2010-09-06
+9329773e204fed50ec686ee78cc715b624bf1b1d weekly.2010-09-15
+1eec33c03bceef5d7607ea4636185f7bf773e0e4 weekly.2010-09-22
+c2b8c9f13fb8ad2b56920d9da2928c5314ebf725 weekly.2010-09-29
+7c2e97710bf49cdbe388260958a6674afefb6c0f weekly.2010-10-13
+ca4f9687cec0b9c4732afd57b8c2786c7fe242de weekly.2010-10-13.1
+79997f0e5823ee9d13a34ca9971a9d8811df1c4a weekly.2010-10-20
+4d5b0816392116d3a3452bb275b6dab6c6456278 weekly.2010-10-27
+c627e23260c7ddf4a1fcda6ef3197c98fa22551d weekly.2010-11-02
+a7800e20064a39585aa3ee339c2b7454ae1ce6d5 weekly.2010-11-10
+c5287468fcff0f8a7bb9ffaece2a4863e7e5d83e weekly.2010-11-23
+f7e692dc29b02fba8e5d59b967880a347b53607c weekly.2010-12-02
+56e39c466cc1c49b587eb56dc2166d61151637df weekly.2010-12-08
+26f4898dc1ca18bb77f9968aca23773637e34f0d weekly.2010-12-15
+61b2c52b0d2246430395f2869d7b34e565333cf5 weekly.2010-12-15.1
+51c777dbccb9f537ebffb99244f521c05bf65df6 weekly.2010-12-22
+8eeee945e358f19405e81792db0e16a1cad14bc0 weekly.2011-01-06
+514c7ba501a1dd74d69ea2d0a2b4116802ada2b5 weekly.2011-01-12
+72f9cb714f08b98c6a65ab2f2256fad6bb16967a weekly.2011-01-19
+d8ba80011a986470a54e5262ec125105aa4adc34 weekly.2011-01-20
+5b98b59dd37292e36afb24babb2d22758928e13d weekly.2011-02-01
+867d37fb41a4d96ab7a6202fd6ad54c345494051 weekly.2011-02-01.1
+b2be017f91348d5f8cbaf42f77a99fc905044b59 weekly.2011-02-15
+322350d6fdbf11d9c404d6fc766349d824031339 weekly.2011-02-24
+21848430d60167817ca965c813a2118068ca660f weekly.2011-03-07
+c5c62aeb6267e124cf05f9622e28dbd0dc6b971d weekly.2011-03-07.1
+c5c62aeb6267e124cf05f9622e28dbd0dc6b971d release.r56
+3b4e9c85b643a35860805718323b05186dd7f235 weekly.2011-03-15
+b84e614e25161f626a6102813c41a80a15e3a625 weekly.2011-03-28
+cd89452cfea3d125aaf75a1ec8004e2f6a868d38 weekly.2011-04-04
+d6903b7fbff40c13ee7ea3177c0ae54c7f89d2e6 weekly.2011-04-13
+2f0fa51fa2da6ab50fcebba526326153da8ed999 weekly.2011-04-27
+8493bb64e5592bd20c0e60e78e7f8052c1276fcf release.r57
+95d2ce135523c96c4cea049af94ce76dd8c7d981 release.r57.1
+c98449d685d2b6aa1df9bfd2e1cce9307efb6e00 weekly.2011-05-22
+3418f22c39eb8299053ae681199ee90f8cd29c6d weekly.2011-06-02
+c81944152e973a917797679055b8fcdc70fbc802 weekly.2011-06-09
+9d7967223815ef6415ff01aa0fe6ad38cdbc7810 release.r57.2
+dac76f0b1a18a5de5b54a1dc0b231aceaf1c8583 weekly.2011-06-16
+541c445d6c1353fbfa39df7dc4b0eb27558d1fc1 weekly.2011-06-23
+1b38d90eebcddefabb3901c5bb63c7e2b04a6ec5 release.r58
+16bfa562ba767aefd82e598da8b15ee4729e23b0 weekly.2011-07-07
+d292bc7886682d35bb391bf572be28656baee12d release.r58.1
+3c21f37b25a3f7a1726265c5339c8a7b0b329336 weekly.2011-07-19
+bb28251f6da4aca85658582c370c7df89d34efd4 weekly.2011-07-29
+d5785050f61d973fc36775f7bd2e26689529cb3e release.r59
+c17ce5ec06b4bd5cf6e7ff2ceb0a60c2e40e0b17 weekly.2011-08-10
+6eb2b9dbe489acb57a2bfc1de31ec2239ed94326 weekly.2011-08-17
+c934f6f5fe8b30b4b3210ee3f13669e6e4670c32 weekly.2011-09-01
+c77997547d546c36c7b969586a36de7ceda74e33 weekly.2011-09-07
+b0819469a6df6029a27192fe7b19a73d97404c63 release.r60
+8a09ce0cefc64deab4e6d1ed59a08a53e879bbee weekly.2011-09-16
+fd30c132d1bdeb79f8f111cb721fb1c78b767b27 release.r60.1
+d7322ae4d055a4cf3efaf842d0717a41acd85bac weekly.2011-09-21
+32a5db19629897641b2d488de4d1b998942ef80e release.r60.2
+3bdabf483805fbf0c7ef013fd09bfd6062b9d3f2 weekly.2011-10-06
+c1702f36df0397c19fc333571a771666029aa37e release.r60.3
+acaddf1cea75c059d19b20dbef35b20fb3f38954 release.r58.2
+6d7136d74b656ba6e1194853a9486375005227ef weekly.2011-10-18
+941b8015061a0f6480954821dd589c60dfe35ed1 weekly.2011-10-25
+7c1f789e6efd153951e85e3f28722fc69efc2af2 weekly.2011-10-26
+e69e528f2afc25a8334cfb9359fa4fcdf2a934b6 weekly.2011-11-01
+780c85032b174c9d4b42adf75d82bc85af7d78d1 weekly.2011-11-02
+f4397ad6e87c7ce5feac9b01686f1ebd6cbaac4e weekly.2011-11-08
+2f4482b89a6b5956828872137b6b96636cd904d3 weekly.2011-11-09
+b4a91b6933748db1a7150c06a1b55ad506e52906 weekly.2011-11-18
+80db2da6495a20ddff8305c236825811db8c8665 weekly.2011-12-01
+0beb796b4ef8747af601ed5ea6766d5b1340086b weekly.2011-12-02
+0c39eee85b0d1606b79c8ebcdeb3b67ed5849e39 weekly.2011-12-06
+82fdc445f2ff2c85043446eb84a19cc999dfcb95 weekly.2011-12-14
+4a82689277582a2a60f006e3f158985f2f8d1da3 weekly.2011-12-22
+354b17404643c0f1a710bdc48927dff02f203ae3 weekly.2012-01-15
+9f2be4fbbf690b9562c6e98b91daa0003f0913c7 weekly.2012-01-20
+1107a7d3cb075836387adfab5ce56d1b3e56637d weekly.2012-01-27
+52ba9506bd993663a0a033c2bd68699e25d061ab weekly.2012-02-07
+43cf9b39b6477d3144b0353ee91096e55db6107f weekly.2012-02-14
+96bd78e7d35e892113bdfa1bdc392d3a5f2e644b weekly.2012-02-22
+f4470a54e6dbcdd52d8d404e12e4754adcd2c948 weekly.2012-03-04
+3cdba7b0650c6c906ef3e782654f61701abd7dd2 weekly.2012-03-13
+bce220d0377405146527ab9478867cbc572a6886 weekly.2012-03-22
+dc5e410f0b4c32ab11dc992593a2bcf5f607381b weekly.2012-03-27
+dc5e410f0b4c32ab11dc992593a2bcf5f607381b weekly
+920e9d1ffd1f46665dd152aa9cf3c0f17d68dd88 go1
+2ccfd4b451d319941bfe3e08037e1462d3c15093 go1.0.1
+5e806355a9e1491aaab53d3612fed4c550b130c0 go1.0.2
+2d8bc3c94ecb3ec8f70556d5fd237788903c7281 go1.0.3
+35da6063e57f8cefc82ba1ea542c4d9393ea9dfd go1.1rc2
+5a15f0dae37931da46f0356cf4cffe775a061c12 go1.1rc3
+e570c2daeaca10663d36d6dee7f8d1d76e8f7b92 go1.1
+a7bd9a33067b3537351276e0178a045748ad046a go1.1.1
+414057ac1f1fc850957088e4c5e95cdbccd2d594 go1.1.2
+45475ec7eab1c588fc4210b34d5901b15ca1e479 go1.2rc2
+7422495a6bf9d5e84828ee466406293be84f565a go1.2rc3
+94af58f9fd71feda5c316d791ed11aaf015f9e82 go1.2rc4
+b3d5a20b070a92da2458c5788694d1359b353f4a go1.2rc5
+87dea3f5ebe7510998c84dbeeec89382b7d42f9c go1.2
+0ddbdc3c7ce27e66508fe58ab81ff29324786026 go1.2.1
+9c4fdd8369ca4483fbed1cb8e67f02643ca10f79 go1.2.2
+f8b50ad4cac4d4c4ecf48324b4f512f65e82cc1c go1.3beta1
+9e1652c32289c164126b6171f024afad5665fc9e go1.3beta2
+9d5451df4e53acc58a848005b7ec3a24c4b6050c go1.3rc1
+3f66a43d5180052e2e1e38d979d1aa5ad05b21f9 go1.3rc2
+9895f9e36435468d503eaa74ee217f28d5e28dd4 go1.3
+073fc578434bf3e1e22749b559d273c8da728ebb go1.3.1
+85518b1d6f8d6e16133b9ed2c9db6807522d37de go1.3.2
+f44017549ff9c3cc5eef74ebe7276cd0dfc066b6 go1.3.3
+f44017549ff9c3cc5eef74ebe7276cd0dfc066b6 release
+1fdfd7dfaedb1b7702141617e621ab7328a236a1 go1.4beta1
--- a/665
+++ b/665
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,40 +0,0 @@
-# Contributing to Go
-
-Go is an open source project.
-
-It is the work of hundreds of contributors. We appreciate your help!
-
-## Before filing an issue
-
-If you are unsure whether you have found a bug, please consider asking in the [golang-nuts mailing
-list](https://groups.google.com/forum/#!forum/golang-nuts) or [other forums](https://golang.org/help/) first. If
-the behavior you are seeing is confirmed as a bug or issue, it can easily be re-raised in the issue tracker.
-
-## Filing issues
-
-Sensitive security-related issues should be reported to [security@golang.org](mailto:security@golang.org).
-See the [security policy](https://golang.org/security) for details.
-
-The recommended way to file an issue is by running `go bug`.
-Otherwise, when filing an issue, make sure to answer these five questions:
-
-1. What version of Go are you using (`go version`)?
-2. What operating system and processor architecture are you using?
-3. What did you do?
-4. What did you expect to see?
-5. What did you see instead?
-
-For change proposals, see [Proposing Changes To Go](https://github.com/golang/proposal/).
-
-## Contributing code
-
-Please read the [Contribution Guidelines](https://golang.org/doc/contribute.html) before sending patches.
-
-**We do not accept GitHub pull requests**
-(we use [an instance](https://go-review.googlesource.com/) of the
-[Gerrit](https://www.gerritcodereview.com/) code review system instead).
-Also, please do not post patches on the issue tracker.
-
-Unless otherwise noted, the Go source files are distributed under
-the BSD-style license found in the LICENSE file.
-
--- a/847
+++ b/847
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
+Copyright (c) 2012 The Go Authors. All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
--- a/32
+++ b/32
@@ -0,0 +1,32 @@
+This is the source code repository for the Go programming language.  
+
+For documentation about how to install and use Go,
+visit http://golang.org/ or load doc/install-source.html
+in your web browser.
+
+After installing Go, you can view a nicely formatted
+doc/install-source.html by running godoc --http=:6060
+and then visiting http://localhost:6060/doc/install/source.
+
+Unless otherwise noted, the Go source files are distributed
+under the BSD-style license found in the LICENSE file.
+
+--
+
+Binary Distribution Notes
+
+If you have just untarred a binary Go distribution, you need to set
+the environment variable $GOROOT to the full path of the go
+directory (the one containing this README).  You can omit the
+variable if you unpack it into /usr/local/go, or if you rebuild
+from sources by running all.bash (see doc/install.html).
+You should also add the Go binary directory $GOROOT/bin
+to your shell's path.
+
+For example, if you extracted the tar file into $HOME/go, you might
+put the following in your .profile:
+
+    export GOROOT=$HOME/go
+    export PATH=$PATH:$GOROOT/bin
+
+See doc/install.html for more details.
--- a/README.md
+++ b/README.md
@@ -1,45 +0,0 @@
-# The Go Programming Language
-
-Go is an open source programming language that makes it easy to build simple,
-reliable, and efficient software.
-
-![Gopher image](doc/gopher/fiveyears.jpg)
-*Gopher image by [Renee French][rf], licensed under [Creative Commons 3.0 Attributions license][cc3-by].*
-
-Our canonical Git repository is located at https://go.googlesource.com/go.
-There is a mirror of the repository at https://github.com/golang/go.
-
-Unless otherwise noted, the Go source files are distributed under the
-BSD-style license found in the LICENSE file.
-
-### Download and Install
-
-#### Binary Distributions
-
-Official binary distributions are available at https://golang.org/dl/.
-
-After downloading a binary release, visit https://golang.org/doc/install
-or load doc/install.html in your web browser for installation
-instructions.
-
-#### Install From Source
-
-If a binary distribution is not available for your combination of
-operating system and architecture, visit
-https://golang.org/doc/install/source or load doc/install-source.html
-in your web browser for source installation instructions.
-
-### Contributing
-
-Go is the work of hundreds of contributors. We appreciate your help!
-
-To contribute, please read the contribution guidelines:
-	https://golang.org/doc/contribute.html
-
-Note that the Go project does not use GitHub pull requests, and that
-we use the issue tracker for bug reports and proposals only. See
-https://golang.org/wiki/Questions for a list of places to ask
-questions about the Go language.
-
-[rf]: https://reneefrench.blogspot.com/
-[cc3-by]: https://creativecommons.org/licenses/by/3.0/
--- a/1
+++ b/1
@@ -0,0 +1 @@
+go1.4rc2
--- a/api/README
+++ b/api/README
@@ -1,6 +1,6 @@
 Files in this directory are data for Go's API checker ("go tool api", in src/cmd/api).

-Each file is a list of API features, one per line.
+Each file is a list of of API features, one per line.

 go1.txt (and similarly named files) are frozen once a version has been
 shipped. Each file adds new lines but does not remove any.
--- a/api/except.txt
+++ b/api/except.txt
@@ -1,108 +1,23 @@
-pkg encoding/json, method (*RawMessage) MarshalJSON() ([]uint8, error)
-pkg math/big, type Word uintptr
 pkg net, func ListenUnixgram(string, *UnixAddr) (*UDPConn, error)
+pkg syscall (darwin-386), func Fchflags(string, int) error
+pkg syscall (darwin-386-cgo), func Fchflags(string, int) error
+pkg syscall (darwin-amd64), func Fchflags(string, int) error
+pkg syscall (darwin-amd64-cgo), func Fchflags(string, int) error
+pkg syscall (freebsd-386), func Fchflags(string, int) error
+pkg syscall (freebsd-amd64), func Fchflags(string, int) error
+pkg syscall (freebsd-arm), func Fchflags(string, int) error
+pkg syscall (freebsd-arm-cgo), func Fchflags(string, int) error
+pkg syscall (netbsd-arm), func Fchflags(string, int) error
+pkg syscall (netbsd-arm-cgo), func Fchflags(string, int) error
+pkg testing, func RegisterCover(Cover)
+pkg text/template/parse, type DotNode bool
+pkg text/template/parse, type Node interface { Copy, String, Type }
 pkg os (linux-arm), const O_SYNC = 4096
 pkg os (linux-arm-cgo), const O_SYNC = 4096
 pkg syscall (darwin-386), const ImplementsGetwd = false
-pkg syscall (darwin-386), func Fchflags(string, int) error
 pkg syscall (darwin-386-cgo), const ImplementsGetwd = false
-pkg syscall (darwin-386-cgo), func Fchflags(string, int) error
 pkg syscall (darwin-amd64), const ImplementsGetwd = false
-pkg syscall (darwin-amd64), func Fchflags(string, int) error
 pkg syscall (darwin-amd64-cgo), const ImplementsGetwd = false
-pkg syscall (darwin-amd64-cgo), func Fchflags(string, int) error
-pkg syscall (freebsd-386), const AF_MAX = 38
-pkg syscall (freebsd-386), const DLT_MATCHING_MAX = 242
-pkg syscall (freebsd-386), const ELAST = 94
-pkg syscall (freebsd-386), const O_CLOEXEC = 0
-pkg syscall (freebsd-386), func Fchflags(string, int) error
-pkg syscall (freebsd-386-cgo), const AF_MAX = 38
-pkg syscall (freebsd-386-cgo), const DLT_MATCHING_MAX = 242
-pkg syscall (freebsd-386-cgo), const ELAST = 94
-pkg syscall (freebsd-386-cgo), const O_CLOEXEC = 0
-pkg syscall (freebsd-amd64), const AF_MAX = 38
-pkg syscall (freebsd-amd64), const DLT_MATCHING_MAX = 242
-pkg syscall (freebsd-amd64), const ELAST = 94
-pkg syscall (freebsd-amd64), const O_CLOEXEC = 0
-pkg syscall (freebsd-amd64), func Fchflags(string, int) error
-pkg syscall (freebsd-amd64-cgo), const AF_MAX = 38
-pkg syscall (freebsd-amd64-cgo), const DLT_MATCHING_MAX = 242
-pkg syscall (freebsd-amd64-cgo), const ELAST = 94
-pkg syscall (freebsd-amd64-cgo), const O_CLOEXEC = 0
-pkg syscall (freebsd-arm), const AF_MAX = 38
-pkg syscall (freebsd-arm), const BIOCGRTIMEOUT = 1074545262
-pkg syscall (freebsd-arm), const BIOCSRTIMEOUT = 2148287085
-pkg syscall (freebsd-arm), const ELAST = 94
-pkg syscall (freebsd-arm), const O_CLOEXEC = 0
-pkg syscall (freebsd-arm), const SIOCAIFADDR = 2151967019
-pkg syscall (freebsd-arm), const SIOCGIFSTATUS = 3274991931
-pkg syscall (freebsd-arm), const SIOCSIFPHYADDR = 2151967046
-pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_GET = 537
-pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_GET ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_LIMIT = 536
-pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_LIMIT ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_GET = 535
-pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_GET ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_LIMIT = 534
-pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_LIMIT ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_GET = 515
-pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_GET ideal-int
-pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_LIMIT = 533
-pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_LIMIT ideal-int
-pkg syscall (freebsd-arm), const SizeofBpfHdr = 24
-pkg syscall (freebsd-arm), const SizeofIfData = 88
-pkg syscall (freebsd-arm), const SizeofIfMsghdr = 104
-pkg syscall (freebsd-arm), const SizeofSockaddrDatalink = 56
-pkg syscall (freebsd-arm), const SizeofSockaddrUnix = 108
-pkg syscall (freebsd-arm), const TIOCTIMESTAMP = 1074558041
-pkg syscall (freebsd-arm), func Fchflags(string, int) error
-pkg syscall (freebsd-arm), type BpfHdr struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm), type RawSockaddrDatalink struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm), type RawSockaddrUnix struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm), type Stat_t struct, Pad_cgo_0 [4]uint8
-pkg syscall (freebsd-arm-cgo), const AF_MAX = 38
-pkg syscall (freebsd-arm-cgo), const BIOCGRTIMEOUT = 1074545262
-pkg syscall (freebsd-arm-cgo), const BIOCSRTIMEOUT = 2148287085
-pkg syscall (freebsd-arm-cgo), const ELAST = 94
-pkg syscall (freebsd-arm-cgo), const O_CLOEXEC = 0
-pkg syscall (freebsd-arm-cgo), const SIOCAIFADDR = 2151967019
-pkg syscall (freebsd-arm-cgo), const SIOCGIFSTATUS = 3274991931
-pkg syscall (freebsd-arm-cgo), const SIOCSIFPHYADDR = 2151967046
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_GET = 537
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_GET ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_LIMIT = 536
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_LIMIT ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_GET = 535
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_GET ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_LIMIT = 534
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_LIMIT ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_GET = 515
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_GET ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_LIMIT = 533
-pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_LIMIT ideal-int
-pkg syscall (freebsd-arm-cgo), const SizeofBpfHdr = 24
-pkg syscall (freebsd-arm-cgo), const SizeofIfData = 88
-pkg syscall (freebsd-arm-cgo), const SizeofIfMsghdr = 104
-pkg syscall (freebsd-arm-cgo), const SizeofSockaddrDatalink = 56
-pkg syscall (freebsd-arm-cgo), const SizeofSockaddrUnix = 108
-pkg syscall (freebsd-arm-cgo), const TIOCTIMESTAMP = 1074558041
-pkg syscall (freebsd-arm-cgo), func Fchflags(string, int) error
-pkg syscall (freebsd-arm-cgo), type BpfHdr struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm-cgo), type RawSockaddrDatalink struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm-cgo), type RawSockaddrUnix struct, Pad_cgo_0 [2]uint8
-pkg syscall (freebsd-arm-cgo), type Stat_t struct, Pad_cgo_0 [4]uint8
-pkg syscall (linux-386), type Cmsghdr struct, X__cmsg_data [0]uint8
-pkg syscall (linux-386-cgo), type Cmsghdr struct, X__cmsg_data [0]uint8
-pkg syscall (linux-amd64), type Cmsghdr struct, X__cmsg_data [0]uint8
-pkg syscall (linux-amd64-cgo), type Cmsghdr struct, X__cmsg_data [0]uint8
-pkg syscall (linux-arm), type Cmsghdr struct, X__cmsg_data [0]uint8
-pkg syscall (linux-arm-cgo), type Cmsghdr struct, X__cmsg_data [0]uint8
-pkg syscall (netbsd-arm), const SizeofIfData = 132
-pkg syscall (netbsd-arm), func Fchflags(string, int) error
-pkg syscall (netbsd-arm), type IfMsghdr struct, Pad_cgo_1 [4]uint8
-pkg syscall (netbsd-arm-cgo), const SizeofIfData = 132
-pkg syscall (netbsd-arm-cgo), func Fchflags(string, int) error
-pkg syscall (netbsd-arm-cgo), type IfMsghdr struct, Pad_cgo_1 [4]uint8
 pkg syscall (openbsd-386), const BIOCGRTIMEOUT = 1074283118
 pkg syscall (openbsd-386), const BIOCSRTIMEOUT = 2148024941
 pkg syscall (openbsd-386), const RTF_FMASK = 63496
@@ -331,15 +246,85 @@ pkg syscall (openbsd-amd64-cgo), type Statfs_t struct, F_spare [3]uint32
 pkg syscall (openbsd-amd64-cgo), type Statfs_t struct, Pad_cgo_1 [4]uint8
 pkg syscall (openbsd-amd64-cgo), type Timespec struct, Pad_cgo_0 [4]uint8
 pkg syscall (openbsd-amd64-cgo), type Timespec struct, Sec int32
-pkg testing, func RegisterCover(Cover)
-pkg testing, func MainStart(func(string, string) (bool, error), []InternalTest, []InternalBenchmark, []InternalExample) *M
-pkg text/template/parse, type DotNode bool
-pkg text/template/parse, type Node interface { Copy, String, Type }
 pkg unicode, const Version = "6.2.0"
+pkg syscall (freebsd-386), const AF_MAX = 38
+pkg syscall (freebsd-386), const DLT_MATCHING_MAX = 242
+pkg syscall (freebsd-386), const ELAST = 94
+pkg syscall (freebsd-386), const O_CLOEXEC = 0
+pkg syscall (freebsd-386-cgo), const AF_MAX = 38
+pkg syscall (freebsd-386-cgo), const DLT_MATCHING_MAX = 242
+pkg syscall (freebsd-386-cgo), const ELAST = 94
+pkg syscall (freebsd-386-cgo), const O_CLOEXEC = 0
+pkg syscall (freebsd-amd64), const AF_MAX = 38
+pkg syscall (freebsd-amd64), const DLT_MATCHING_MAX = 242
+pkg syscall (freebsd-amd64), const ELAST = 94
+pkg syscall (freebsd-amd64), const O_CLOEXEC = 0
+pkg syscall (freebsd-amd64-cgo), const AF_MAX = 38
+pkg syscall (freebsd-amd64-cgo), const DLT_MATCHING_MAX = 242
+pkg syscall (freebsd-amd64-cgo), const ELAST = 94
+pkg syscall (freebsd-amd64-cgo), const O_CLOEXEC = 0
+pkg syscall (freebsd-arm), const AF_MAX = 38
+pkg syscall (freebsd-arm), const BIOCGRTIMEOUT = 1074545262
+pkg syscall (freebsd-arm), const BIOCSRTIMEOUT = 2148287085
+pkg syscall (freebsd-arm), const ELAST = 94
+pkg syscall (freebsd-arm), const O_CLOEXEC = 0
+pkg syscall (freebsd-arm), const SIOCAIFADDR = 2151967019
+pkg syscall (freebsd-arm), const SIOCGIFSTATUS = 3274991931
+pkg syscall (freebsd-arm), const SIOCSIFPHYADDR = 2151967046
+pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_GET = 537
+pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_GET ideal-int
+pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_LIMIT = 536
+pkg syscall (freebsd-arm), const SYS_CAP_FCNTLS_LIMIT ideal-int
+pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_GET = 535
+pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_GET ideal-int
+pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_LIMIT = 534
+pkg syscall (freebsd-arm), const SYS_CAP_IOCTLS_LIMIT ideal-int
+pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_GET = 515
+pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_GET ideal-int
+pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_LIMIT = 533
+pkg syscall (freebsd-arm), const SYS_CAP_RIGHTS_LIMIT ideal-int
+pkg syscall (freebsd-arm), const SizeofBpfHdr = 24
+pkg syscall (freebsd-arm), const SizeofIfData = 88
+pkg syscall (freebsd-arm), const SizeofIfMsghdr = 104
+pkg syscall (freebsd-arm), const SizeofSockaddrDatalink = 56
+pkg syscall (freebsd-arm), const SizeofSockaddrUnix = 108
+pkg syscall (freebsd-arm), const TIOCTIMESTAMP = 1074558041
+pkg syscall (freebsd-arm), type BpfHdr struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm), type RawSockaddrDatalink struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm), type RawSockaddrUnix struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm), type Stat_t struct, Pad_cgo_0 [4]uint8
+pkg syscall (freebsd-arm-cgo), const AF_MAX = 38
+pkg syscall (freebsd-arm-cgo), const BIOCGRTIMEOUT = 1074545262
+pkg syscall (freebsd-arm-cgo), const BIOCSRTIMEOUT = 2148287085
+pkg syscall (freebsd-arm-cgo), const ELAST = 94
+pkg syscall (freebsd-arm-cgo), const O_CLOEXEC = 0
+pkg syscall (freebsd-arm-cgo), const SIOCAIFADDR = 2151967019
+pkg syscall (freebsd-arm-cgo), const SIOCGIFSTATUS = 3274991931
+pkg syscall (freebsd-arm-cgo), const SIOCSIFPHYADDR = 2151967046
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_GET = 537
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_GET ideal-int
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_LIMIT = 536
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_FCNTLS_LIMIT ideal-int
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_GET = 535
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_GET ideal-int
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_LIMIT = 534
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_IOCTLS_LIMIT ideal-int
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_GET = 515
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_GET ideal-int
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_LIMIT = 533
+pkg syscall (freebsd-arm-cgo), const SYS_CAP_RIGHTS_LIMIT ideal-int
+pkg syscall (freebsd-arm-cgo), const SizeofBpfHdr = 24
+pkg syscall (freebsd-arm-cgo), const SizeofIfData = 88
+pkg syscall (freebsd-arm-cgo), const SizeofIfMsghdr = 104
+pkg syscall (freebsd-arm-cgo), const SizeofSockaddrDatalink = 56
+pkg syscall (freebsd-arm-cgo), const SizeofSockaddrUnix = 108
+pkg syscall (freebsd-arm-cgo), const TIOCTIMESTAMP = 1074558041
+pkg syscall (freebsd-arm-cgo), type BpfHdr struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm-cgo), type RawSockaddrDatalink struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm-cgo), type RawSockaddrUnix struct, Pad_cgo_0 [2]uint8
+pkg syscall (freebsd-arm-cgo), type Stat_t struct, Pad_cgo_0 [4]uint8
+pkg syscall (netbsd-arm), const SizeofIfData = 132
+pkg syscall (netbsd-arm), type IfMsghdr struct, Pad_cgo_1 [4]uint8
+pkg syscall (netbsd-arm-cgo), const SizeofIfData = 132
+pkg syscall (netbsd-arm-cgo), type IfMsghdr struct, Pad_cgo_1 [4]uint8
 pkg unicode, const Version = "6.3.0"
-pkg unicode, const Version = "7.0.0"
-pkg unicode, const Version = "8.0.0"
-pkg syscall (openbsd-386), const SYS_KILL = 37
-pkg syscall (openbsd-386-cgo), const SYS_KILL = 37
-pkg syscall (openbsd-amd64), const SYS_KILL = 37
-pkg syscall (openbsd-amd64-cgo), const SYS_KILL = 37
--- a/api/go1.1.txt
+++ b/api/go1.1.txt
@@ -1983,13 +1983,13 @@ pkg log/syslog (openbsd-amd64-cgo), const LOG_SYSLOG = 40
 pkg log/syslog (openbsd-amd64-cgo), const LOG_USER = 8
 pkg log/syslog (openbsd-amd64-cgo), const LOG_UUCP = 64
 pkg log/syslog (openbsd-amd64-cgo), const LOG_WARNING = 4
-pkg math, const E = 2.71828  // 271828182845904523536028747135266249775724709369995957496696763/100000000000000000000000000000000000000000000000000000000000000
-pkg math, const Ln10 = 2.30259  // 23025850929940456840179914546843642076011014886287729760333279/10000000000000000000000000000000000000000000000000000000000000
-pkg math, const Ln2 = 0.693147  // 693147180559945309417232121458176568075500134360255254120680009/1000000000000000000000000000000000000000000000000000000000000000
-pkg math, const Log10E = 0.434294  // 10000000000000000000000000000000000000000000000000000000000000/23025850929940456840179914546843642076011014886287729760333279
-pkg math, const Log2E = 1.4427  // 1000000000000000000000000000000000000000000000000000000000000000/693147180559945309417232121458176568075500134360255254120680009
-pkg math, const MaxFloat32 = 3.40282e+38  // 340282346638528859811704183484516925440
-pkg math, const MaxFloat64 = 1.79769e+308  // 179769313486231570814527423731704356798100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+pkg math, const E = 271828182845904523536028747135266249775724709369995957496696763/100000000000000000000000000000000000000000000000000000000000000
+pkg math, const Ln10 = 23025850929940456840179914546843642076011014886287729760333279/10000000000000000000000000000000000000000000000000000000000000
+pkg math, const Ln2 = 693147180559945309417232121458176568075500134360255254120680009/1000000000000000000000000000000000000000000000000000000000000000
+pkg math, const Log10E = 10000000000000000000000000000000000000000000000000000000000000/23025850929940456840179914546843642076011014886287729760333279
+pkg math, const Log2E = 1000000000000000000000000000000000000000000000000000000000000000/693147180559945309417232121458176568075500134360255254120680009
+pkg math, const MaxFloat32 = 340282346638528859811704183484516925440
+pkg math, const MaxFloat64 = 179769313486231570814527423731704356798100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 pkg math, const MaxInt16 = 32767
 pkg math, const MaxInt32 = 2147483647
 pkg math, const MaxInt64 = 9223372036854775807
@@ -2002,14 +2002,14 @@ pkg math, const MinInt16 = -32768
 pkg math, const MinInt32 = -2147483648
 pkg math, const MinInt64 = -9223372036854775808
 pkg math, const MinInt8 = -128
-pkg math, const Phi = 1.61803  // 80901699437494742410229341718281905886015458990288143106772431/50000000000000000000000000000000000000000000000000000000000000
-pkg math, const Pi = 3.14159  // 314159265358979323846264338327950288419716939937510582097494459/100000000000000000000000000000000000000000000000000000000000000
-pkg math, const SmallestNonzeroFloat32 = 1.4013e-45  // 17516230804060213386546619791123951641/12500000000000000000000000000000000000000000000000000000000000000000000000000000000
-pkg math, const SmallestNonzeroFloat64 = 4.94066e-324  // 4940656458412465441765687928682213723651/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
-pkg math, const Sqrt2 = 1.41421  // 70710678118654752440084436210484903928483593768847403658833987/50000000000000000000000000000000000000000000000000000000000000
-pkg math, const SqrtE = 1.64872  // 164872127070012814684865078781416357165377610071014801157507931/100000000000000000000000000000000000000000000000000000000000000
-pkg math, const SqrtPhi = 1.27202  // 63600982475703448212621123086874574585780402092004812430832019/50000000000000000000000000000000000000000000000000000000000000
-pkg math, const SqrtPi = 1.77245  // 177245385090551602729816748334114518279754945612238712821380779/100000000000000000000000000000000000000000000000000000000000000
+pkg math, const Phi = 80901699437494742410229341718281905886015458990288143106772431/50000000000000000000000000000000000000000000000000000000000000
+pkg math, const Pi = 314159265358979323846264338327950288419716939937510582097494459/100000000000000000000000000000000000000000000000000000000000000
+pkg math, const SmallestNonzeroFloat32 = 17516230804060213386546619791123951641/12500000000000000000000000000000000000000000000000000000000000000000000000000000000
+pkg math, const SmallestNonzeroFloat64 = 4940656458412465441765687928682213723651/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+pkg math, const Sqrt2 = 70710678118654752440084436210484903928483593768847403658833987/50000000000000000000000000000000000000000000000000000000000000
+pkg math, const SqrtE = 164872127070012814684865078781416357165377610071014801157507931/100000000000000000000000000000000000000000000000000000000000000
+pkg math, const SqrtPhi = 63600982475703448212621123086874574585780402092004812430832019/50000000000000000000000000000000000000000000000000000000000000
+pkg math, const SqrtPi = 177245385090551602729816748334114518279754945612238712821380779/100000000000000000000000000000000000000000000000000000000000000
 pkg math/big, const MaxBase = 36
 pkg math/big, method (*Int) MarshalJSON() ([]uint8, error)
 pkg math/big, method (*Int) SetUint64(uint64) *Int
--- a/api/go1.4.txt
+++ b/api/go1.4.txt
@@ -1,604 +0,0 @@
-# CL 134210043 archive/zip: add Writer.Flush, Brad Fitzpatrick <bradfitz@golang.org>
-pkg archive/zip, method (*Writer) Flush() error
-
-# CL 97140043 compress/flate: add Reset() to allow reusing large buffers to compress multiple buffers, James Robinson <jamesr@google.com>
-pkg compress/flate, type Resetter interface { Reset }
-pkg compress/flate, type Resetter interface, Reset(io.Reader, []uint8) error
-pkg compress/zlib, type Resetter interface { Reset }
-pkg compress/zlib, type Resetter interface, Reset(io.Reader, []uint8) error
-
-# CL 159120044 compress/gzip: allow stopping at end of first stream, Russ Cox <rsc@golang.org>
-pkg compress/gzip, method (*Reader) Multistream(bool)
-
-# CL 138800043 crypto: Add SHA3 functions in go.crypto/sha3 to the Hash enum., David Leon Gil <coruus@gmail.com>
-pkg crypto, const SHA3_224 = 10
-pkg crypto, const SHA3_224 Hash
-pkg crypto, const SHA3_256 = 11
-pkg crypto, const SHA3_256 Hash
-pkg crypto, const SHA3_384 = 12
-pkg crypto, const SHA3_384 Hash
-pkg crypto, const SHA3_512 = 13
-pkg crypto, const SHA3_512 Hash
-
-# CL 114680043 crypto: add Signer, Adam Langley <agl@golang.org>
-pkg crypto, method (Hash) HashFunc() Hash
-pkg crypto, type Signer interface { Public, Sign }
-pkg crypto, type Signer interface, Public() PublicKey
-pkg crypto, type Signer interface, Sign(io.Reader, []uint8, SignerOpts) ([]uint8, error)
-pkg crypto, type SignerOpts interface { HashFunc }
-pkg crypto, type SignerOpts interface, HashFunc() Hash
-pkg crypto/ecdsa, method (*PrivateKey) Public() crypto.PublicKey
-pkg crypto/ecdsa, method (*PrivateKey) Sign(io.Reader, []uint8, crypto.SignerOpts) ([]uint8, error)
-pkg crypto/rsa, method (*PSSOptions) HashFunc() crypto.Hash
-pkg crypto/rsa, method (*PrivateKey) Public() crypto.PublicKey
-pkg crypto/rsa, method (*PrivateKey) Sign(io.Reader, []uint8, crypto.SignerOpts) ([]uint8, error)
-pkg crypto/rsa, type PSSOptions struct, Hash crypto.Hash
-
-# CL 157090043 crypto/tls: support TLS_FALLBACK_SCSV as a server., Adam Langley <agl@golang.org>
-pkg crypto/tls, const TLS_FALLBACK_SCSV = 22016
-pkg crypto/tls, const TLS_FALLBACK_SCSV uint16
-
-# CL 107400043 crypto/tls: Added dynamic alternative to NameToCertificate map for SNI, Percy Wegmann <ox.to.a.cart@gmail.com>
-pkg crypto/tls, type ClientHelloInfo struct
-pkg crypto/tls, type ClientHelloInfo struct, CipherSuites []uint16
-pkg crypto/tls, type ClientHelloInfo struct, ServerName string
-pkg crypto/tls, type ClientHelloInfo struct, SupportedCurves []CurveID
-pkg crypto/tls, type ClientHelloInfo struct, SupportedPoints []uint8
-pkg crypto/tls, type Config struct, GetCertificate func(*ClientHelloInfo) (*Certificate, error)
-pkg crypto/tls, type ConnectionState struct, TLSUnique []uint8
-
-# CL 153420045 crypto/x509: continue to recognise MaxPathLen of zero as "no value"., Adam Langley <agl@golang.org>
-pkg crypto/x509, type Certificate struct, MaxPathLenZero bool
-
-# CL 158950043 database/sql: add Drivers, returning list of registered drivers, Russ Cox <rsc@golang.org>
-pkg database/sql, func Drivers() []string
-
-# CL 117280043 debug/dwarf: fix Reader panic on DW_TAG_unspecified_type, Derek Parker <parkerderek86@gmail.com>
-pkg debug/dwarf, method (*UnspecifiedType) Basic() *BasicType
-pkg debug/dwarf, method (*UnspecifiedType) Common() *CommonType
-pkg debug/dwarf, method (*UnspecifiedType) Size() int64
-pkg debug/dwarf, method (*UnspecifiedType) String() string
-pkg debug/dwarf, type UnspecifiedType struct
-pkg debug/dwarf, type UnspecifiedType struct, embedded BasicType
-
-# CL 132000043 debug/elf: support arm64 relocations, Michael Hudson-Doyle <michael.hudson@linaro.org>
-pkg debug/elf, const EM_AARCH64 = 183
-pkg debug/elf, const EM_AARCH64 Machine
-pkg debug/elf, const R_AARCH64_ABS16 = 259
-pkg debug/elf, const R_AARCH64_ABS16 R_AARCH64
-pkg debug/elf, const R_AARCH64_ABS32 = 258
-pkg debug/elf, const R_AARCH64_ABS32 R_AARCH64
-pkg debug/elf, const R_AARCH64_ABS64 = 257
-pkg debug/elf, const R_AARCH64_ABS64 R_AARCH64
-pkg debug/elf, const R_AARCH64_ADD_ABS_LO12_NC = 277
-pkg debug/elf, const R_AARCH64_ADD_ABS_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_ADR_GOT_PAGE = 311
-pkg debug/elf, const R_AARCH64_ADR_GOT_PAGE R_AARCH64
-pkg debug/elf, const R_AARCH64_ADR_PREL_LO21 = 274
-pkg debug/elf, const R_AARCH64_ADR_PREL_LO21 R_AARCH64
-pkg debug/elf, const R_AARCH64_ADR_PREL_PG_HI21 = 275
-pkg debug/elf, const R_AARCH64_ADR_PREL_PG_HI21 R_AARCH64
-pkg debug/elf, const R_AARCH64_ADR_PREL_PG_HI21_NC = 276
-pkg debug/elf, const R_AARCH64_ADR_PREL_PG_HI21_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_CALL26 = 283
-pkg debug/elf, const R_AARCH64_CALL26 R_AARCH64
-pkg debug/elf, const R_AARCH64_CONDBR19 = 280
-pkg debug/elf, const R_AARCH64_CONDBR19 R_AARCH64
-pkg debug/elf, const R_AARCH64_COPY = 1024
-pkg debug/elf, const R_AARCH64_COPY R_AARCH64
-pkg debug/elf, const R_AARCH64_GLOB_DAT = 1025
-pkg debug/elf, const R_AARCH64_GLOB_DAT R_AARCH64
-pkg debug/elf, const R_AARCH64_GOT_LD_PREL19 = 309
-pkg debug/elf, const R_AARCH64_GOT_LD_PREL19 R_AARCH64
-pkg debug/elf, const R_AARCH64_IRELATIVE = 1032
-pkg debug/elf, const R_AARCH64_IRELATIVE R_AARCH64
-pkg debug/elf, const R_AARCH64_JUMP26 = 282
-pkg debug/elf, const R_AARCH64_JUMP26 R_AARCH64
-pkg debug/elf, const R_AARCH64_JUMP_SLOT = 1026
-pkg debug/elf, const R_AARCH64_JUMP_SLOT R_AARCH64
-pkg debug/elf, const R_AARCH64_LD64_GOT_LO12_NC = 312
-pkg debug/elf, const R_AARCH64_LD64_GOT_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_LDST128_ABS_LO12_NC = 299
-pkg debug/elf, const R_AARCH64_LDST128_ABS_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_LDST16_ABS_LO12_NC = 284
-pkg debug/elf, const R_AARCH64_LDST16_ABS_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_LDST32_ABS_LO12_NC = 285
-pkg debug/elf, const R_AARCH64_LDST32_ABS_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_LDST64_ABS_LO12_NC = 286
-pkg debug/elf, const R_AARCH64_LDST64_ABS_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_LDST8_ABS_LO12_NC = 278
-pkg debug/elf, const R_AARCH64_LDST8_ABS_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_LD_PREL_LO19 = 273
-pkg debug/elf, const R_AARCH64_LD_PREL_LO19 R_AARCH64
-pkg debug/elf, const R_AARCH64_MOVW_SABS_G0 = 270
-pkg debug/elf, const R_AARCH64_MOVW_SABS_G0 R_AARCH64
-pkg debug/elf, const R_AARCH64_MOVW_SABS_G1 = 271
-pkg debug/elf, const R_AARCH64_MOVW_SABS_G1 R_AARCH64
-pkg debug/elf, const R_AARCH64_MOVW_SABS_G2 = 272
-pkg debug/elf, const R_AARCH64_MOVW_SABS_G2 R_AARCH64
-pkg debug/elf, const R_AARCH64_MOVW_UABS_G0 = 263
-pkg debug/elf, const R_AARCH64_MOVW_UABS_G0 R_AARCH64
-pkg debug/elf, const R_AARCH64_MOVW_UABS_G0_NC = 264
-pkg debug/elf, const R_AARCH64_MOVW_UABS_G0_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_MOVW_UABS_G1 = 265
-pkg debug/elf, const R_AARCH64_MOVW_UABS_G1 R_AARCH64
-pkg debug/elf, const R_AARCH64_MOVW_UABS_G1_NC = 266
-pkg debug/elf, const R_AARCH64_MOVW_UABS_G1_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_MOVW_UABS_G2 = 267
-pkg debug/elf, const R_AARCH64_MOVW_UABS_G2 R_AARCH64
-pkg debug/elf, const R_AARCH64_MOVW_UABS_G2_NC = 268
-pkg debug/elf, const R_AARCH64_MOVW_UABS_G2_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_MOVW_UABS_G3 = 269
-pkg debug/elf, const R_AARCH64_MOVW_UABS_G3 R_AARCH64
-pkg debug/elf, const R_AARCH64_NONE = 0
-pkg debug/elf, const R_AARCH64_NONE R_AARCH64
-pkg debug/elf, const R_AARCH64_NULL = 256
-pkg debug/elf, const R_AARCH64_NULL R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_ABS16 = 2
-pkg debug/elf, const R_AARCH64_P32_ABS16 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_ABS32 = 1
-pkg debug/elf, const R_AARCH64_P32_ABS32 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_ADD_ABS_LO12_NC = 12
-pkg debug/elf, const R_AARCH64_P32_ADD_ABS_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_ADR_GOT_PAGE = 26
-pkg debug/elf, const R_AARCH64_P32_ADR_GOT_PAGE R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_ADR_PREL_LO21 = 10
-pkg debug/elf, const R_AARCH64_P32_ADR_PREL_LO21 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_ADR_PREL_PG_HI21 = 11
-pkg debug/elf, const R_AARCH64_P32_ADR_PREL_PG_HI21 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_CALL26 = 21
-pkg debug/elf, const R_AARCH64_P32_CALL26 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_CONDBR19 = 19
-pkg debug/elf, const R_AARCH64_P32_CONDBR19 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_COPY = 180
-pkg debug/elf, const R_AARCH64_P32_COPY R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_GLOB_DAT = 181
-pkg debug/elf, const R_AARCH64_P32_GLOB_DAT R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_GOT_LD_PREL19 = 25
-pkg debug/elf, const R_AARCH64_P32_GOT_LD_PREL19 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_IRELATIVE = 188
-pkg debug/elf, const R_AARCH64_P32_IRELATIVE R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_JUMP26 = 20
-pkg debug/elf, const R_AARCH64_P32_JUMP26 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_JUMP_SLOT = 182
-pkg debug/elf, const R_AARCH64_P32_JUMP_SLOT R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_LD32_GOT_LO12_NC = 27
-pkg debug/elf, const R_AARCH64_P32_LD32_GOT_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_LDST128_ABS_LO12_NC = 17
-pkg debug/elf, const R_AARCH64_P32_LDST128_ABS_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_LDST16_ABS_LO12_NC = 14
-pkg debug/elf, const R_AARCH64_P32_LDST16_ABS_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_LDST32_ABS_LO12_NC = 15
-pkg debug/elf, const R_AARCH64_P32_LDST32_ABS_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_LDST64_ABS_LO12_NC = 16
-pkg debug/elf, const R_AARCH64_P32_LDST64_ABS_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_LDST8_ABS_LO12_NC = 13
-pkg debug/elf, const R_AARCH64_P32_LDST8_ABS_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_LD_PREL_LO19 = 9
-pkg debug/elf, const R_AARCH64_P32_LD_PREL_LO19 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_MOVW_SABS_G0 = 8
-pkg debug/elf, const R_AARCH64_P32_MOVW_SABS_G0 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_MOVW_UABS_G0 = 5
-pkg debug/elf, const R_AARCH64_P32_MOVW_UABS_G0 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_MOVW_UABS_G0_NC = 6
-pkg debug/elf, const R_AARCH64_P32_MOVW_UABS_G0_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_MOVW_UABS_G1 = 7
-pkg debug/elf, const R_AARCH64_P32_MOVW_UABS_G1 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_PREL16 = 4
-pkg debug/elf, const R_AARCH64_P32_PREL16 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_PREL32 = 3
-pkg debug/elf, const R_AARCH64_P32_PREL32 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_RELATIVE = 183
-pkg debug/elf, const R_AARCH64_P32_RELATIVE R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSDESC = 187
-pkg debug/elf, const R_AARCH64_P32_TLSDESC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSDESC_ADD_LO12_NC = 126
-pkg debug/elf, const R_AARCH64_P32_TLSDESC_ADD_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSDESC_ADR_PAGE21 = 124
-pkg debug/elf, const R_AARCH64_P32_TLSDESC_ADR_PAGE21 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSDESC_ADR_PREL21 = 123
-pkg debug/elf, const R_AARCH64_P32_TLSDESC_ADR_PREL21 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSDESC_CALL = 127
-pkg debug/elf, const R_AARCH64_P32_TLSDESC_CALL R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSDESC_LD32_LO12_NC = 125
-pkg debug/elf, const R_AARCH64_P32_TLSDESC_LD32_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSDESC_LD_PREL19 = 122
-pkg debug/elf, const R_AARCH64_P32_TLSDESC_LD_PREL19 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSGD_ADD_LO12_NC = 82
-pkg debug/elf, const R_AARCH64_P32_TLSGD_ADD_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSGD_ADR_PAGE21 = 81
-pkg debug/elf, const R_AARCH64_P32_TLSGD_ADR_PAGE21 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSIE_ADR_GOTTPREL_PAGE21 = 103
-pkg debug/elf, const R_AARCH64_P32_TLSIE_ADR_GOTTPREL_PAGE21 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSIE_LD32_GOTTPREL_LO12_NC = 104
-pkg debug/elf, const R_AARCH64_P32_TLSIE_LD32_GOTTPREL_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSIE_LD_GOTTPREL_PREL19 = 105
-pkg debug/elf, const R_AARCH64_P32_TLSIE_LD_GOTTPREL_PREL19 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSLE_ADD_TPREL_HI12 = 109
-pkg debug/elf, const R_AARCH64_P32_TLSLE_ADD_TPREL_HI12 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSLE_ADD_TPREL_LO12 = 110
-pkg debug/elf, const R_AARCH64_P32_TLSLE_ADD_TPREL_LO12 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSLE_ADD_TPREL_LO12_NC = 111
-pkg debug/elf, const R_AARCH64_P32_TLSLE_ADD_TPREL_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSLE_MOVW_TPREL_G0 = 107
-pkg debug/elf, const R_AARCH64_P32_TLSLE_MOVW_TPREL_G0 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSLE_MOVW_TPREL_G0_NC = 108
-pkg debug/elf, const R_AARCH64_P32_TLSLE_MOVW_TPREL_G0_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLSLE_MOVW_TPREL_G1 = 106
-pkg debug/elf, const R_AARCH64_P32_TLSLE_MOVW_TPREL_G1 R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLS_DTPMOD = 184
-pkg debug/elf, const R_AARCH64_P32_TLS_DTPMOD R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLS_DTPREL = 185
-pkg debug/elf, const R_AARCH64_P32_TLS_DTPREL R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TLS_TPREL = 186
-pkg debug/elf, const R_AARCH64_P32_TLS_TPREL R_AARCH64
-pkg debug/elf, const R_AARCH64_P32_TSTBR14 = 18
-pkg debug/elf, const R_AARCH64_P32_TSTBR14 R_AARCH64
-pkg debug/elf, const R_AARCH64_PREL16 = 262
-pkg debug/elf, const R_AARCH64_PREL16 R_AARCH64
-pkg debug/elf, const R_AARCH64_PREL32 = 261
-pkg debug/elf, const R_AARCH64_PREL32 R_AARCH64
-pkg debug/elf, const R_AARCH64_PREL64 = 260
-pkg debug/elf, const R_AARCH64_PREL64 R_AARCH64
-pkg debug/elf, const R_AARCH64_RELATIVE = 1027
-pkg debug/elf, const R_AARCH64_RELATIVE R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSDESC = 1031
-pkg debug/elf, const R_AARCH64_TLSDESC R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSDESC_ADD = 568
-pkg debug/elf, const R_AARCH64_TLSDESC_ADD R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSDESC_ADD_LO12_NC = 564
-pkg debug/elf, const R_AARCH64_TLSDESC_ADD_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSDESC_ADR_PAGE21 = 562
-pkg debug/elf, const R_AARCH64_TLSDESC_ADR_PAGE21 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSDESC_ADR_PREL21 = 561
-pkg debug/elf, const R_AARCH64_TLSDESC_ADR_PREL21 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSDESC_CALL = 569
-pkg debug/elf, const R_AARCH64_TLSDESC_CALL R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSDESC_LD64_LO12_NC = 563
-pkg debug/elf, const R_AARCH64_TLSDESC_LD64_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSDESC_LDR = 567
-pkg debug/elf, const R_AARCH64_TLSDESC_LDR R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSDESC_LD_PREL19 = 560
-pkg debug/elf, const R_AARCH64_TLSDESC_LD_PREL19 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSDESC_OFF_G0_NC = 566
-pkg debug/elf, const R_AARCH64_TLSDESC_OFF_G0_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSDESC_OFF_G1 = 565
-pkg debug/elf, const R_AARCH64_TLSDESC_OFF_G1 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSGD_ADD_LO12_NC = 514
-pkg debug/elf, const R_AARCH64_TLSGD_ADD_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSGD_ADR_PAGE21 = 513
-pkg debug/elf, const R_AARCH64_TLSGD_ADR_PAGE21 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 = 541
-pkg debug/elf, const R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC = 542
-pkg debug/elf, const R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSIE_LD_GOTTPREL_PREL19 = 543
-pkg debug/elf, const R_AARCH64_TLSIE_LD_GOTTPREL_PREL19 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC = 540
-pkg debug/elf, const R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSIE_MOVW_GOTTPREL_G1 = 539
-pkg debug/elf, const R_AARCH64_TLSIE_MOVW_GOTTPREL_G1 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSLE_ADD_TPREL_HI12 = 549
-pkg debug/elf, const R_AARCH64_TLSLE_ADD_TPREL_HI12 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSLE_ADD_TPREL_LO12 = 550
-pkg debug/elf, const R_AARCH64_TLSLE_ADD_TPREL_LO12 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSLE_ADD_TPREL_LO12_NC = 551
-pkg debug/elf, const R_AARCH64_TLSLE_ADD_TPREL_LO12_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSLE_MOVW_TPREL_G0 = 547
-pkg debug/elf, const R_AARCH64_TLSLE_MOVW_TPREL_G0 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSLE_MOVW_TPREL_G0_NC = 548
-pkg debug/elf, const R_AARCH64_TLSLE_MOVW_TPREL_G0_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSLE_MOVW_TPREL_G1 = 545
-pkg debug/elf, const R_AARCH64_TLSLE_MOVW_TPREL_G1 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSLE_MOVW_TPREL_G1_NC = 546
-pkg debug/elf, const R_AARCH64_TLSLE_MOVW_TPREL_G1_NC R_AARCH64
-pkg debug/elf, const R_AARCH64_TLSLE_MOVW_TPREL_G2 = 544
-pkg debug/elf, const R_AARCH64_TLSLE_MOVW_TPREL_G2 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLS_DTPMOD64 = 1028
-pkg debug/elf, const R_AARCH64_TLS_DTPMOD64 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLS_DTPREL64 = 1029
-pkg debug/elf, const R_AARCH64_TLS_DTPREL64 R_AARCH64
-pkg debug/elf, const R_AARCH64_TLS_TPREL64 = 1030
-pkg debug/elf, const R_AARCH64_TLS_TPREL64 R_AARCH64
-pkg debug/elf, const R_AARCH64_TSTBR14 = 279
-pkg debug/elf, const R_AARCH64_TSTBR14 R_AARCH64
-pkg debug/elf, method (R_AARCH64) GoString() string
-pkg debug/elf, method (R_AARCH64) String() string
-pkg debug/elf, type R_AARCH64 int
-
-# CL 107530043 debug/elf: add (*File).DynamicSymbols, ErrNoSymbols, and tests for (*File).Symbols and (*File).DynamicSymbols, and formalize symbol order., Pietro Gagliardi <pietro10@mac.com>
-pkg debug/elf, method (*File) DynamicSymbols() ([]Symbol, error)
-pkg debug/elf, var ErrNoSymbols error
-
-# CL 106460044 debug/plan9obj, cmd/addr2line: on Plan 9 use a.out header, Aram Hăvărneanu <aram@mgk.ro>
-pkg debug/plan9obj, type FileHeader struct, HdrSize uint64
-pkg debug/plan9obj, type FileHeader struct, LoadAddress uint64
-
-# CL 122960043 encoding/xml: add InputOffset method to Decoder, Russ Cox <rsc@golang.org>
-pkg encoding/xml, method (*Decoder) InputOffset() int64
-
-# CL 124940043 cmd/go, go/build: implement import comment checking, Russ Cox <rsc@golang.org>
-pkg go/build, const ImportComment = 4
-pkg go/build, const ImportComment ImportMode
-pkg go/build, type Package struct, ImportComment string
-
-# CL 155050043 go/build: Return MultiplePackageError on importing a dir containing multiple packages, Jens Frederich <jfrederich@gmail.com>
-pkg go/build, method (*MultiplePackageError) Error() string
-pkg go/build, type MultiplePackageError struct
-pkg go/build, type MultiplePackageError struct, Dir string
-pkg go/build, type MultiplePackageError struct, Files []string
-pkg go/build, type MultiplePackageError struct, Packages []string
-
-# CL 135110044 go/token: implement PositionFor accessors, Robert Griesemer <gri@golang.org>
-pkg go/token, method (*File) PositionFor(Pos, bool) Position
-pkg go/token, method (*FileSet) PositionFor(Pos, bool) Position
-
-# CL 109000049 image: add RGBAAt, Gray16At, etc., ChaiShushan <chaishushan@gmail.com>
-pkg image, method (*Alpha) AlphaAt(int, int) color.Alpha
-pkg image, method (*Alpha16) Alpha16At(int, int) color.Alpha16
-pkg image, method (*Gray) GrayAt(int, int) color.Gray
-pkg image, method (*Gray16) Gray16At(int, int) color.Gray16
-pkg image, method (*NRGBA) NRGBAAt(int, int) color.NRGBA
-pkg image, method (*NRGBA64) NRGBA64At(int, int) color.NRGBA64
-pkg image, method (*RGBA) RGBAAt(int, int) color.RGBA
-pkg image, method (*RGBA64) RGBA64At(int, int) color.RGBA64
-pkg image, method (*YCbCr) YCbCrAt(int, int) color.YCbCr
-
-# CL 129190043 png: make the encoder configurable, Jeff R. Allen <jra@nella.org>
-pkg image/png, const BestCompression = -3
-pkg image/png, const BestCompression CompressionLevel
-pkg image/png, const BestSpeed = -2
-pkg image/png, const BestSpeed CompressionLevel
-pkg image/png, const DefaultCompression = 0
-pkg image/png, const DefaultCompression CompressionLevel
-pkg image/png, const NoCompression = -1
-pkg image/png, const NoCompression CompressionLevel
-pkg image/png, method (*Encoder) Encode(io.Writer, image.Image) error
-pkg image/png, type CompressionLevel int
-pkg image/png, type Encoder struct
-pkg image/png, type Encoder struct, CompressionLevel CompressionLevel
-
-# CL 101750048 math: implement Nextafter32, Robert Griesemer <gri@golang.org>
-pkg math, func Nextafter32(float32, float32) float32
-
-# CL 93550043 math/big: implement Rat.Float32, Robert Griesemer <gri@golang.org>
-pkg math/big, method (*Rat) Float32() (float32, bool)
-
-# CL 76540043 net/http: add BasicAuth method to *http.Request, Kelsey Hightower <kelsey.hightower@gmail.com>
-pkg net/http, method (*Request) BasicAuth() (string, string, bool)
-
-# CL 137940043 net/http: add Transport.DialTLS hook, Brad Fitzpatrick <bradfitz@golang.org>
-pkg net/http, type Transport struct, DialTLS func(string, string) (net.Conn, error)
-
-# CL 132750043 net/http/httputil: Pass a Logger to ReverseProxy, allowing the user to control logging., Mark Theunissen <mark.theunissen@gmail.com>
-pkg net/http/httputil, type ReverseProxy struct, ErrorLog *log.Logger
-
-# CL 148370043 os, syscall: add Unsetenv, Brad Fitzpatrick <bradfitz@golang.org>
-pkg os, func Unsetenv(string) error
-pkg syscall, func Unsetenv(string) error
-
-# CL 144020043 reflect: add Type.Comparable, Russ Cox <rsc@golang.org>
-pkg reflect, type Type interface, Comparable() bool
-
-# CL 153670043 runtime: add PauseEnd array to MemStats and GCStats, Jens Frederich <jfrederich@gmail.com>
-pkg runtime, type MemStats struct, PauseEnd [256]uint64
-pkg runtime/debug, type GCStats struct, PauseEnd []time.Time
-
-# CL 136710045 sync/atomic: add Value, Dmitriy Vyukov <dvyukov@google.com>
-pkg sync/atomic, method (*Value) Load() interface{}
-pkg sync/atomic, method (*Value) Store(interface{})
-pkg sync/atomic, type Value struct
-
-# CL 126190043 syscall: support UID/GID map files for Linux user namespaces, Mrunal Patel <mrunalp@gmail.com>
-pkg syscall (linux-386), type SysProcAttr struct, GidMappings []SysProcIDMap
-pkg syscall (linux-386), type SysProcAttr struct, UidMappings []SysProcIDMap
-pkg syscall (linux-386), type SysProcIDMap struct
-pkg syscall (linux-386), type SysProcIDMap struct, ContainerID int
-pkg syscall (linux-386), type SysProcIDMap struct, HostID int
-pkg syscall (linux-386), type SysProcIDMap struct, Size int
-pkg syscall (linux-386-cgo), type SysProcAttr struct, GidMappings []SysProcIDMap
-pkg syscall (linux-386-cgo), type SysProcAttr struct, UidMappings []SysProcIDMap
-pkg syscall (linux-386-cgo), type SysProcIDMap struct
-pkg syscall (linux-386-cgo), type SysProcIDMap struct, ContainerID int
-pkg syscall (linux-386-cgo), type SysProcIDMap struct, HostID int
-pkg syscall (linux-386-cgo), type SysProcIDMap struct, Size int
-pkg syscall (linux-amd64), type SysProcAttr struct, GidMappings []SysProcIDMap
-pkg syscall (linux-amd64), type SysProcAttr struct, UidMappings []SysProcIDMap
-pkg syscall (linux-amd64), type SysProcIDMap struct
-pkg syscall (linux-amd64), type SysProcIDMap struct, ContainerID int
-pkg syscall (linux-amd64), type SysProcIDMap struct, HostID int
-pkg syscall (linux-amd64), type SysProcIDMap struct, Size int
-pkg syscall (linux-amd64-cgo), type SysProcAttr struct, GidMappings []SysProcIDMap
-pkg syscall (linux-amd64-cgo), type SysProcAttr struct, UidMappings []SysProcIDMap
-pkg syscall (linux-amd64-cgo), type SysProcIDMap struct
-pkg syscall (linux-amd64-cgo), type SysProcIDMap struct, ContainerID int
-pkg syscall (linux-amd64-cgo), type SysProcIDMap struct, HostID int
-pkg syscall (linux-amd64-cgo), type SysProcIDMap struct, Size int
-pkg syscall (linux-arm), type SysProcAttr struct, GidMappings []SysProcIDMap
-pkg syscall (linux-arm), type SysProcAttr struct, UidMappings []SysProcIDMap
-pkg syscall (linux-arm), type SysProcIDMap struct
-pkg syscall (linux-arm), type SysProcIDMap struct, ContainerID int
-pkg syscall (linux-arm), type SysProcIDMap struct, HostID int
-pkg syscall (linux-arm), type SysProcIDMap struct, Size int
-pkg syscall (linux-arm-cgo), type SysProcAttr struct, GidMappings []SysProcIDMap
-pkg syscall (linux-arm-cgo), type SysProcAttr struct, UidMappings []SysProcIDMap
-pkg syscall (linux-arm-cgo), type SysProcIDMap struct
-pkg syscall (linux-arm-cgo), type SysProcIDMap struct, ContainerID int
-pkg syscall (linux-arm-cgo), type SysProcIDMap struct, HostID int
-pkg syscall (linux-arm-cgo), type SysProcIDMap struct, Size int
-
-# CL 122200043 net: fix CNAME resolving on Windows, Egon Elbre <egonelbre@gmail.com>
-pkg syscall (windows-386), const DNS_INFO_NO_RECORDS = 9501
-pkg syscall (windows-386), const DNS_INFO_NO_RECORDS ideal-int
-pkg syscall (windows-386), const DnsSectionAdditional = 3
-pkg syscall (windows-386), const DnsSectionAdditional ideal-int
-pkg syscall (windows-386), const DnsSectionAnswer = 1
-pkg syscall (windows-386), const DnsSectionAnswer ideal-int
-pkg syscall (windows-386), const DnsSectionAuthority = 2
-pkg syscall (windows-386), const DnsSectionAuthority ideal-int
-pkg syscall (windows-386), const DnsSectionQuestion = 0
-pkg syscall (windows-386), const DnsSectionQuestion ideal-int
-pkg syscall (windows-386), func DnsNameCompare(*uint16, *uint16) bool
-pkg syscall (windows-amd64), const DNS_INFO_NO_RECORDS = 9501
-pkg syscall (windows-amd64), const DNS_INFO_NO_RECORDS ideal-int
-pkg syscall (windows-amd64), const DnsSectionAdditional = 3
-pkg syscall (windows-amd64), const DnsSectionAdditional ideal-int
-pkg syscall (windows-amd64), const DnsSectionAnswer = 1
-pkg syscall (windows-amd64), const DnsSectionAnswer ideal-int
-pkg syscall (windows-amd64), const DnsSectionAuthority = 2
-pkg syscall (windows-amd64), const DnsSectionAuthority ideal-int
-pkg syscall (windows-amd64), const DnsSectionQuestion = 0
-pkg syscall (windows-amd64), const DnsSectionQuestion ideal-int
-pkg syscall (windows-amd64), func DnsNameCompare(*uint16, *uint16) bool
-
-# CL 86160044 os: Implement symlink support for Windows, Michael Fraenkel <michael.fraenkel@gmail.com>
-pkg syscall (windows-386), const ERROR_PRIVILEGE_NOT_HELD = 1314
-pkg syscall (windows-386), const ERROR_PRIVILEGE_NOT_HELD Errno
-pkg syscall (windows-amd64), const ERROR_PRIVILEGE_NOT_HELD = 1314
-pkg syscall (windows-amd64), const ERROR_PRIVILEGE_NOT_HELD Errno
-
-# CL 86160044 os: Implement symlink support for Windows, Michael Fraenkel <michael.fraenkel@gmail.com>
-pkg syscall (windows-386), const FILE_ATTRIBUTE_REPARSE_POINT = 1024
-pkg syscall (windows-386), const FILE_ATTRIBUTE_REPARSE_POINT ideal-int
-pkg syscall (windows-386), const FILE_FLAG_OPEN_REPARSE_POINT = 2097152
-pkg syscall (windows-386), const FILE_FLAG_OPEN_REPARSE_POINT ideal-int
-pkg syscall (windows-386), const FSCTL_GET_REPARSE_POINT = 589992
-pkg syscall (windows-386), const FSCTL_GET_REPARSE_POINT ideal-int
-pkg syscall (windows-386), const IO_REPARSE_TAG_SYMLINK = 2684354572
-pkg syscall (windows-386), const IO_REPARSE_TAG_SYMLINK ideal-int
-pkg syscall (windows-386), const MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 16384
-pkg syscall (windows-386), const MAXIMUM_REPARSE_DATA_BUFFER_SIZE ideal-int
-pkg syscall (windows-386), const SYMBOLIC_LINK_FLAG_DIRECTORY = 1
-pkg syscall (windows-386), const SYMBOLIC_LINK_FLAG_DIRECTORY ideal-int
-pkg syscall (windows-386), func CreateHardLink(*uint16, *uint16, uintptr) error
-pkg syscall (windows-386), func CreateSymbolicLink(*uint16, *uint16, uint32) error
-pkg syscall (windows-386), func DeviceIoControl(Handle, uint32, *uint8, uint32, *uint8, uint32, *uint32, *Overlapped) error
-pkg syscall (windows-386), func LoadCreateSymbolicLink() error
-pkg syscall (windows-amd64), const FILE_ATTRIBUTE_REPARSE_POINT = 1024
-pkg syscall (windows-amd64), const FILE_ATTRIBUTE_REPARSE_POINT ideal-int
-pkg syscall (windows-amd64), const FILE_FLAG_OPEN_REPARSE_POINT = 2097152
-pkg syscall (windows-amd64), const FILE_FLAG_OPEN_REPARSE_POINT ideal-int
-pkg syscall (windows-amd64), const FSCTL_GET_REPARSE_POINT = 589992
-pkg syscall (windows-amd64), const FSCTL_GET_REPARSE_POINT ideal-int
-pkg syscall (windows-amd64), const IO_REPARSE_TAG_SYMLINK = 2684354572
-pkg syscall (windows-amd64), const IO_REPARSE_TAG_SYMLINK ideal-int
-pkg syscall (windows-amd64), const MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 16384
-pkg syscall (windows-amd64), const MAXIMUM_REPARSE_DATA_BUFFER_SIZE ideal-int
-pkg syscall (windows-amd64), const SYMBOLIC_LINK_FLAG_DIRECTORY = 1
-pkg syscall (windows-amd64), const SYMBOLIC_LINK_FLAG_DIRECTORY ideal-int
-pkg syscall (windows-amd64), func CreateHardLink(*uint16, *uint16, uintptr) error
-pkg syscall (windows-amd64), func CreateSymbolicLink(*uint16, *uint16, uint32) error
-pkg syscall (windows-amd64), func DeviceIoControl(Handle, uint32, *uint8, uint32, *uint8, uint32, *uint32, *Overlapped) error
-pkg syscall (windows-amd64), func LoadCreateSymbolicLink() error
-
-# CL 149510043 net: disable SIO_UDP_CONNRESET behavior on windows., Ron Hashimoto <mail@h2so5.net>
-pkg syscall (windows-386), const SIO_UDP_CONNRESET = 2550136844
-pkg syscall (windows-386), const SIO_UDP_CONNRESET ideal-int
-pkg syscall (windows-amd64), const SIO_UDP_CONNRESET = 2550136844
-pkg syscall (windows-amd64), const SIO_UDP_CONNRESET ideal-int
-
-# CL 102320044 syscall: implement syscall.Getppid() on Windows, Alan Shreve <alan@inconshreveable.com>
-pkg syscall (windows-386), const TH32CS_INHERIT = 2147483648
-pkg syscall (windows-386), const TH32CS_INHERIT ideal-int
-pkg syscall (windows-386), const TH32CS_SNAPALL = 15
-pkg syscall (windows-386), const TH32CS_SNAPALL ideal-int
-pkg syscall (windows-386), const TH32CS_SNAPHEAPLIST = 1
-pkg syscall (windows-386), const TH32CS_SNAPHEAPLIST ideal-int
-pkg syscall (windows-386), const TH32CS_SNAPMODULE = 8
-pkg syscall (windows-386), const TH32CS_SNAPMODULE ideal-int
-pkg syscall (windows-386), const TH32CS_SNAPMODULE32 = 16
-pkg syscall (windows-386), const TH32CS_SNAPMODULE32 ideal-int
-pkg syscall (windows-386), const TH32CS_SNAPPROCESS = 2
-pkg syscall (windows-386), const TH32CS_SNAPPROCESS ideal-int
-pkg syscall (windows-386), const TH32CS_SNAPTHREAD = 4
-pkg syscall (windows-386), const TH32CS_SNAPTHREAD ideal-int
-pkg syscall (windows-386), func CreateToolhelp32Snapshot(uint32, uint32) (Handle, error)
-pkg syscall (windows-386), func Process32First(Handle, *ProcessEntry32) error
-pkg syscall (windows-386), func Process32Next(Handle, *ProcessEntry32) error
-pkg syscall (windows-386), type ProcessEntry32 struct
-pkg syscall (windows-386), type ProcessEntry32 struct, DefaultHeapID uintptr
-pkg syscall (windows-386), type ProcessEntry32 struct, ExeFile [260]uint16
-pkg syscall (windows-386), type ProcessEntry32 struct, Flags uint32
-pkg syscall (windows-386), type ProcessEntry32 struct, ModuleID uint32
-pkg syscall (windows-386), type ProcessEntry32 struct, ParentProcessID uint32
-pkg syscall (windows-386), type ProcessEntry32 struct, PriClassBase int32
-pkg syscall (windows-386), type ProcessEntry32 struct, ProcessID uint32
-pkg syscall (windows-386), type ProcessEntry32 struct, Size uint32
-pkg syscall (windows-386), type ProcessEntry32 struct, Threads uint32
-pkg syscall (windows-386), type ProcessEntry32 struct, Usage uint32
-pkg syscall (windows-amd64), const TH32CS_INHERIT = 2147483648
-pkg syscall (windows-amd64), const TH32CS_INHERIT ideal-int
-pkg syscall (windows-amd64), const TH32CS_SNAPALL = 15
-pkg syscall (windows-amd64), const TH32CS_SNAPALL ideal-int
-pkg syscall (windows-amd64), const TH32CS_SNAPHEAPLIST = 1
-pkg syscall (windows-amd64), const TH32CS_SNAPHEAPLIST ideal-int
-pkg syscall (windows-amd64), const TH32CS_SNAPMODULE = 8
-pkg syscall (windows-amd64), const TH32CS_SNAPMODULE ideal-int
-pkg syscall (windows-amd64), const TH32CS_SNAPMODULE32 = 16
-pkg syscall (windows-amd64), const TH32CS_SNAPMODULE32 ideal-int
-pkg syscall (windows-amd64), const TH32CS_SNAPPROCESS = 2
-pkg syscall (windows-amd64), const TH32CS_SNAPPROCESS ideal-int
-pkg syscall (windows-amd64), const TH32CS_SNAPTHREAD = 4
-pkg syscall (windows-amd64), const TH32CS_SNAPTHREAD ideal-int
-pkg syscall (windows-amd64), func CreateToolhelp32Snapshot(uint32, uint32) (Handle, error)
-pkg syscall (windows-amd64), func Process32First(Handle, *ProcessEntry32) error
-pkg syscall (windows-amd64), func Process32Next(Handle, *ProcessEntry32) error
-pkg syscall (windows-amd64), type ProcessEntry32 struct
-pkg syscall (windows-amd64), type ProcessEntry32 struct, DefaultHeapID uintptr
-pkg syscall (windows-amd64), type ProcessEntry32 struct, ExeFile [260]uint16
-pkg syscall (windows-amd64), type ProcessEntry32 struct, Flags uint32
-pkg syscall (windows-amd64), type ProcessEntry32 struct, ModuleID uint32
-pkg syscall (windows-amd64), type ProcessEntry32 struct, ParentProcessID uint32
-pkg syscall (windows-amd64), type ProcessEntry32 struct, PriClassBase int32
-pkg syscall (windows-amd64), type ProcessEntry32 struct, ProcessID uint32
-pkg syscall (windows-amd64), type ProcessEntry32 struct, Size uint32
-pkg syscall (windows-amd64), type ProcessEntry32 struct, Threads uint32
-pkg syscall (windows-amd64), type ProcessEntry32 struct, Usage uint32
-
-# CL 127740043 os: make SameFile handle paths like c:a.txt properly, Alex Brainman <alex.brainman@gmail.com>
-pkg syscall (windows-386), func FullPath(string) (string, error)
-pkg syscall (windows-amd64), func FullPath(string) (string, error)
-
-# CL 98150043 testing: add Coverage function, Russ Cox <rsc@golang.org>
-pkg testing, func Coverage() float64
-
-# CL 148770043 cmd/go, testing: add TestMain support, Russ Cox <rsc@golang.org>
-pkg testing, func MainStart(func(string, string) (bool, error), []InternalTest, []InternalBenchmark, []InternalExample) *M
-pkg testing, method (*M) Run() int
-pkg testing, type M struct
-
-# CL 108030044 text/scanner: provide facility for custom identifiers, Robert Griesemer <gri@golang.org>
-pkg text/scanner, type Scanner struct, IsIdentRune func(int32, int) bool
-
-# CL 130620043 text/template: add back pointer to Nodes for better error generation, Rob Pike <r@golang.org>
-pkg text/template/parse, type DotNode struct, embedded NodeType
-pkg text/template/parse, type NilNode struct, embedded NodeType
-pkg text/template/parse, method (*BranchNode) Copy() Node
-pkg text/template/parse, method (*IdentifierNode) SetTree(*Tree) *IdentifierNode
-pkg html/template, type Error struct, Node parse.Node
-
-# CL 127470043 unicode: strconv: regexp: Upgrade to Unicode 7.0.0., Marcel van Lohuizen <mpvl@golang.org>
-pkg unicode, const Version = "7.0.0"
-pkg unicode, var Bassa_Vah *RangeTable
-pkg unicode, var Caucasian_Albanian *RangeTable
-pkg unicode, var Duployan *RangeTable
-pkg unicode, var Elbasan *RangeTable
-pkg unicode, var Grantha *RangeTable
-pkg unicode, var Khojki *RangeTable
-pkg unicode, var Khudawadi *RangeTable
-pkg unicode, var Linear_A *RangeTable
-pkg unicode, var Mahajani *RangeTable
-pkg unicode, var Manichaean *RangeTable
-pkg unicode, var Mende_Kikakui *RangeTable
-pkg unicode, var Modi *RangeTable
-pkg unicode, var Mro *RangeTable
-pkg unicode, var Nabataean *RangeTable
-pkg unicode, var Old_North_Arabian *RangeTable
-pkg unicode, var Old_Permic *RangeTable
-pkg unicode, var Pahawh_Hmong *RangeTable
-pkg unicode, var Palmyrene *RangeTable
-pkg unicode, var Pau_Cin_Hau *RangeTable
-pkg unicode, var Psalter_Pahlavi *RangeTable
-pkg unicode, var Siddham *RangeTable
-pkg unicode, var Tirhuta *RangeTable
-pkg unicode, var Warang_Citi *RangeTable
--- a/api/go1.5.txt
+++ b/api/go1.5.txt
@@ -1,975 +0,0 @@
-pkg archive/zip, method (*Writer) SetOffset(int64)
-pkg bufio, method (*Reader) Discard(int) (int, error)
-pkg bufio, method (ReadWriter) Discard(int) (int, error)
-pkg bytes, func LastIndexByte([]uint8, uint8) int
-pkg bytes, method (*Buffer) Cap() int
-pkg bytes, method (*Reader) Size() int64
-pkg crypto, const SHA512_224 = 14
-pkg crypto, const SHA512_224 Hash
-pkg crypto, const SHA512_256 = 15
-pkg crypto, const SHA512_256 Hash
-pkg crypto, type Decrypter interface { Decrypt, Public }
-pkg crypto, type Decrypter interface, Decrypt(io.Reader, []uint8, DecrypterOpts) ([]uint8, error)
-pkg crypto, type Decrypter interface, Public() PublicKey
-pkg crypto, type DecrypterOpts interface {}
-pkg crypto/cipher, func NewGCMWithNonceSize(Block, int) (AEAD, error)
-pkg crypto/elliptic, type CurveParams struct, Name string
-pkg crypto/rsa, method (*PrivateKey) Decrypt(io.Reader, []uint8, crypto.DecrypterOpts) ([]uint8, error)
-pkg crypto/rsa, type OAEPOptions struct
-pkg crypto/rsa, type OAEPOptions struct, Hash crypto.Hash
-pkg crypto/rsa, type OAEPOptions struct, Label []uint8
-pkg crypto/rsa, type PKCS1v15DecryptOptions struct
-pkg crypto/rsa, type PKCS1v15DecryptOptions struct, SessionKeyLen int
-pkg crypto/sha512, const Size224 = 28
-pkg crypto/sha512, const Size224 ideal-int
-pkg crypto/sha512, const Size256 = 32
-pkg crypto/sha512, const Size256 ideal-int
-pkg crypto/sha512, func New512_224() hash.Hash
-pkg crypto/sha512, func New512_256() hash.Hash
-pkg crypto/sha512, func Sum512_224([]uint8) [28]uint8
-pkg crypto/sha512, func Sum512_256([]uint8) [32]uint8
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = 49196
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 uint16
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = 49200
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 uint16
-pkg crypto/tls, method (*Config) SetSessionTicketKeys([][32]uint8)
-pkg crypto/tls, type Certificate struct, SignedCertificateTimestamps [][]uint8
-pkg crypto/tls, type ConnectionState struct, OCSPResponse []uint8
-pkg crypto/tls, type ConnectionState struct, SignedCertificateTimestamps [][]uint8
-pkg crypto/x509, method (*CertificateRequest) CheckSignature() error
-pkg crypto/x509, type Certificate struct, UnhandledCriticalExtensions []asn1.ObjectIdentifier
-pkg crypto/x509/pkix, type Name struct, ExtraNames []AttributeTypeAndValue
-pkg database/sql, method (*DB) Stats() DBStats
-pkg database/sql, type DBStats struct
-pkg database/sql, type DBStats struct, OpenConnections int
-pkg debug/dwarf, const ClassAddress = 1
-pkg debug/dwarf, const ClassAddress Class
-pkg debug/dwarf, const ClassBlock = 2
-pkg debug/dwarf, const ClassBlock Class
-pkg debug/dwarf, const ClassConstant = 3
-pkg debug/dwarf, const ClassConstant Class
-pkg debug/dwarf, const ClassExprLoc = 4
-pkg debug/dwarf, const ClassExprLoc Class
-pkg debug/dwarf, const ClassFlag = 5
-pkg debug/dwarf, const ClassFlag Class
-pkg debug/dwarf, const ClassLinePtr = 6
-pkg debug/dwarf, const ClassLinePtr Class
-pkg debug/dwarf, const ClassLocListPtr = 7
-pkg debug/dwarf, const ClassLocListPtr Class
-pkg debug/dwarf, const ClassMacPtr = 8
-pkg debug/dwarf, const ClassMacPtr Class
-pkg debug/dwarf, const ClassRangeListPtr = 9
-pkg debug/dwarf, const ClassRangeListPtr Class
-pkg debug/dwarf, const ClassReference = 10
-pkg debug/dwarf, const ClassReference Class
-pkg debug/dwarf, const ClassReferenceAlt = 13
-pkg debug/dwarf, const ClassReferenceAlt Class
-pkg debug/dwarf, const ClassReferenceSig = 11
-pkg debug/dwarf, const ClassReferenceSig Class
-pkg debug/dwarf, const ClassString = 12
-pkg debug/dwarf, const ClassString Class
-pkg debug/dwarf, const ClassStringAlt = 14
-pkg debug/dwarf, const ClassStringAlt Class
-pkg debug/dwarf, method (*Data) LineReader(*Entry) (*LineReader, error)
-pkg debug/dwarf, method (*Entry) AttrField(Attr) *Field
-pkg debug/dwarf, method (*LineReader) Next(*LineEntry) error
-pkg debug/dwarf, method (*LineReader) Reset()
-pkg debug/dwarf, method (*LineReader) Seek(LineReaderPos)
-pkg debug/dwarf, method (*LineReader) SeekPC(uint64, *LineEntry) error
-pkg debug/dwarf, method (*LineReader) Tell() LineReaderPos
-pkg debug/dwarf, method (*Reader) AddressSize() int
-pkg debug/dwarf, method (Class) GoString() string
-pkg debug/dwarf, method (Class) String() string
-pkg debug/dwarf, type Class int
-pkg debug/dwarf, type Field struct, Class Class
-pkg debug/dwarf, type LineEntry struct
-pkg debug/dwarf, type LineEntry struct, Address uint64
-pkg debug/dwarf, type LineEntry struct, BasicBlock bool
-pkg debug/dwarf, type LineEntry struct, Column int
-pkg debug/dwarf, type LineEntry struct, Discriminator int
-pkg debug/dwarf, type LineEntry struct, EndSequence bool
-pkg debug/dwarf, type LineEntry struct, EpilogueBegin bool
-pkg debug/dwarf, type LineEntry struct, File *LineFile
-pkg debug/dwarf, type LineEntry struct, ISA int
-pkg debug/dwarf, type LineEntry struct, IsStmt bool
-pkg debug/dwarf, type LineEntry struct, Line int
-pkg debug/dwarf, type LineEntry struct, OpIndex int
-pkg debug/dwarf, type LineEntry struct, PrologueEnd bool
-pkg debug/dwarf, type LineFile struct
-pkg debug/dwarf, type LineFile struct, Length int
-pkg debug/dwarf, type LineFile struct, Mtime uint64
-pkg debug/dwarf, type LineFile struct, Name string
-pkg debug/dwarf, type LineReader struct
-pkg debug/dwarf, type LineReaderPos struct
-pkg debug/dwarf, var ErrUnknownPC error
-pkg debug/elf, const R_PPC64_ADDR14 = 7
-pkg debug/elf, const R_PPC64_ADDR14 R_PPC64
-pkg debug/elf, const R_PPC64_ADDR14_BRNTAKEN = 9
-pkg debug/elf, const R_PPC64_ADDR14_BRNTAKEN R_PPC64
-pkg debug/elf, const R_PPC64_ADDR14_BRTAKEN = 8
-pkg debug/elf, const R_PPC64_ADDR14_BRTAKEN R_PPC64
-pkg debug/elf, const R_PPC64_ADDR16 = 3
-pkg debug/elf, const R_PPC64_ADDR16 R_PPC64
-pkg debug/elf, const R_PPC64_ADDR16_DS = 56
-pkg debug/elf, const R_PPC64_ADDR16_DS R_PPC64
-pkg debug/elf, const R_PPC64_ADDR16_HA = 6
-pkg debug/elf, const R_PPC64_ADDR16_HA R_PPC64
-pkg debug/elf, const R_PPC64_ADDR16_HI = 5
-pkg debug/elf, const R_PPC64_ADDR16_HI R_PPC64
-pkg debug/elf, const R_PPC64_ADDR16_HIGHER = 39
-pkg debug/elf, const R_PPC64_ADDR16_HIGHER R_PPC64
-pkg debug/elf, const R_PPC64_ADDR16_HIGHERA = 40
-pkg debug/elf, const R_PPC64_ADDR16_HIGHERA R_PPC64
-pkg debug/elf, const R_PPC64_ADDR16_HIGHEST = 41
-pkg debug/elf, const R_PPC64_ADDR16_HIGHEST R_PPC64
-pkg debug/elf, const R_PPC64_ADDR16_HIGHESTA = 42
-pkg debug/elf, const R_PPC64_ADDR16_HIGHESTA R_PPC64
-pkg debug/elf, const R_PPC64_ADDR16_LO = 4
-pkg debug/elf, const R_PPC64_ADDR16_LO R_PPC64
-pkg debug/elf, const R_PPC64_ADDR16_LO_DS = 57
-pkg debug/elf, const R_PPC64_ADDR16_LO_DS R_PPC64
-pkg debug/elf, const R_PPC64_ADDR24 = 2
-pkg debug/elf, const R_PPC64_ADDR24 R_PPC64
-pkg debug/elf, const R_PPC64_ADDR32 = 1
-pkg debug/elf, const R_PPC64_ADDR32 R_PPC64
-pkg debug/elf, const R_PPC64_ADDR64 = 38
-pkg debug/elf, const R_PPC64_ADDR64 R_PPC64
-pkg debug/elf, const R_PPC64_DTPMOD64 = 68
-pkg debug/elf, const R_PPC64_DTPMOD64 R_PPC64
-pkg debug/elf, const R_PPC64_DTPREL16 = 74
-pkg debug/elf, const R_PPC64_DTPREL16 R_PPC64
-pkg debug/elf, const R_PPC64_DTPREL16_DS = 101
-pkg debug/elf, const R_PPC64_DTPREL16_DS R_PPC64
-pkg debug/elf, const R_PPC64_DTPREL16_HA = 77
-pkg debug/elf, const R_PPC64_DTPREL16_HA R_PPC64
-pkg debug/elf, const R_PPC64_DTPREL16_HI = 76
-pkg debug/elf, const R_PPC64_DTPREL16_HI R_PPC64
-pkg debug/elf, const R_PPC64_DTPREL16_HIGHER = 103
-pkg debug/elf, const R_PPC64_DTPREL16_HIGHER R_PPC64
-pkg debug/elf, const R_PPC64_DTPREL16_HIGHERA = 104
-pkg debug/elf, const R_PPC64_DTPREL16_HIGHERA R_PPC64
-pkg debug/elf, const R_PPC64_DTPREL16_HIGHEST = 105
-pkg debug/elf, const R_PPC64_DTPREL16_HIGHEST R_PPC64
-pkg debug/elf, const R_PPC64_DTPREL16_HIGHESTA = 106
-pkg debug/elf, const R_PPC64_DTPREL16_HIGHESTA R_PPC64
-pkg debug/elf, const R_PPC64_DTPREL16_LO = 75
-pkg debug/elf, const R_PPC64_DTPREL16_LO R_PPC64
-pkg debug/elf, const R_PPC64_DTPREL16_LO_DS = 102
-pkg debug/elf, const R_PPC64_DTPREL16_LO_DS R_PPC64
-pkg debug/elf, const R_PPC64_DTPREL64 = 78
-pkg debug/elf, const R_PPC64_DTPREL64 R_PPC64
-pkg debug/elf, const R_PPC64_GOT16 = 14
-pkg debug/elf, const R_PPC64_GOT16 R_PPC64
-pkg debug/elf, const R_PPC64_GOT16_DS = 58
-pkg debug/elf, const R_PPC64_GOT16_DS R_PPC64
-pkg debug/elf, const R_PPC64_GOT16_HA = 17
-pkg debug/elf, const R_PPC64_GOT16_HA R_PPC64
-pkg debug/elf, const R_PPC64_GOT16_HI = 16
-pkg debug/elf, const R_PPC64_GOT16_HI R_PPC64
-pkg debug/elf, const R_PPC64_GOT16_LO = 15
-pkg debug/elf, const R_PPC64_GOT16_LO R_PPC64
-pkg debug/elf, const R_PPC64_GOT16_LO_DS = 59
-pkg debug/elf, const R_PPC64_GOT16_LO_DS R_PPC64
-pkg debug/elf, const R_PPC64_GOT_DTPREL16_DS = 91
-pkg debug/elf, const R_PPC64_GOT_DTPREL16_DS R_PPC64
-pkg debug/elf, const R_PPC64_GOT_DTPREL16_HA = 94
-pkg debug/elf, const R_PPC64_GOT_DTPREL16_HA R_PPC64
-pkg debug/elf, const R_PPC64_GOT_DTPREL16_HI = 93
-pkg debug/elf, const R_PPC64_GOT_DTPREL16_HI R_PPC64
-pkg debug/elf, const R_PPC64_GOT_DTPREL16_LO_DS = 92
-pkg debug/elf, const R_PPC64_GOT_DTPREL16_LO_DS R_PPC64
-pkg debug/elf, const R_PPC64_GOT_TLSGD16 = 79
-pkg debug/elf, const R_PPC64_GOT_TLSGD16 R_PPC64
-pkg debug/elf, const R_PPC64_GOT_TLSGD16_HA = 82
-pkg debug/elf, const R_PPC64_GOT_TLSGD16_HA R_PPC64
-pkg debug/elf, const R_PPC64_GOT_TLSGD16_HI = 81
-pkg debug/elf, const R_PPC64_GOT_TLSGD16_HI R_PPC64
-pkg debug/elf, const R_PPC64_GOT_TLSGD16_LO = 80
-pkg debug/elf, const R_PPC64_GOT_TLSGD16_LO R_PPC64
-pkg debug/elf, const R_PPC64_GOT_TLSLD16 = 83
-pkg debug/elf, const R_PPC64_GOT_TLSLD16 R_PPC64
-pkg debug/elf, const R_PPC64_GOT_TLSLD16_HA = 86
-pkg debug/elf, const R_PPC64_GOT_TLSLD16_HA R_PPC64
-pkg debug/elf, const R_PPC64_GOT_TLSLD16_HI = 85
-pkg debug/elf, const R_PPC64_GOT_TLSLD16_HI R_PPC64
-pkg debug/elf, const R_PPC64_GOT_TLSLD16_LO = 84
-pkg debug/elf, const R_PPC64_GOT_TLSLD16_LO R_PPC64
-pkg debug/elf, const R_PPC64_GOT_TPREL16_DS = 87
-pkg debug/elf, const R_PPC64_GOT_TPREL16_DS R_PPC64
-pkg debug/elf, const R_PPC64_GOT_TPREL16_HA = 90
-pkg debug/elf, const R_PPC64_GOT_TPREL16_HA R_PPC64
-pkg debug/elf, const R_PPC64_GOT_TPREL16_HI = 89
-pkg debug/elf, const R_PPC64_GOT_TPREL16_HI R_PPC64
-pkg debug/elf, const R_PPC64_GOT_TPREL16_LO_DS = 88
-pkg debug/elf, const R_PPC64_GOT_TPREL16_LO_DS R_PPC64
-pkg debug/elf, const R_PPC64_JMP_SLOT = 21
-pkg debug/elf, const R_PPC64_JMP_SLOT R_PPC64
-pkg debug/elf, const R_PPC64_NONE = 0
-pkg debug/elf, const R_PPC64_NONE R_PPC64
-pkg debug/elf, const R_PPC64_REL14 = 11
-pkg debug/elf, const R_PPC64_REL14 R_PPC64
-pkg debug/elf, const R_PPC64_REL14_BRNTAKEN = 13
-pkg debug/elf, const R_PPC64_REL14_BRNTAKEN R_PPC64
-pkg debug/elf, const R_PPC64_REL14_BRTAKEN = 12
-pkg debug/elf, const R_PPC64_REL14_BRTAKEN R_PPC64
-pkg debug/elf, const R_PPC64_REL16 = 249
-pkg debug/elf, const R_PPC64_REL16 R_PPC64
-pkg debug/elf, const R_PPC64_REL16_HA = 252
-pkg debug/elf, const R_PPC64_REL16_HA R_PPC64
-pkg debug/elf, const R_PPC64_REL16_HI = 251
-pkg debug/elf, const R_PPC64_REL16_HI R_PPC64
-pkg debug/elf, const R_PPC64_REL16_LO = 250
-pkg debug/elf, const R_PPC64_REL16_LO R_PPC64
-pkg debug/elf, const R_PPC64_REL24 = 10
-pkg debug/elf, const R_PPC64_REL24 R_PPC64
-pkg debug/elf, const R_PPC64_REL32 = 26
-pkg debug/elf, const R_PPC64_REL32 R_PPC64
-pkg debug/elf, const R_PPC64_REL64 = 44
-pkg debug/elf, const R_PPC64_REL64 R_PPC64
-pkg debug/elf, const R_PPC64_TLS = 67
-pkg debug/elf, const R_PPC64_TLS R_PPC64
-pkg debug/elf, const R_PPC64_TLSGD = 107
-pkg debug/elf, const R_PPC64_TLSGD R_PPC64
-pkg debug/elf, const R_PPC64_TLSLD = 108
-pkg debug/elf, const R_PPC64_TLSLD R_PPC64
-pkg debug/elf, const R_PPC64_TOC = 51
-pkg debug/elf, const R_PPC64_TOC R_PPC64
-pkg debug/elf, const R_PPC64_TOC16 = 47
-pkg debug/elf, const R_PPC64_TOC16 R_PPC64
-pkg debug/elf, const R_PPC64_TOC16_DS = 63
-pkg debug/elf, const R_PPC64_TOC16_DS R_PPC64
-pkg debug/elf, const R_PPC64_TOC16_HA = 50
-pkg debug/elf, const R_PPC64_TOC16_HA R_PPC64
-pkg debug/elf, const R_PPC64_TOC16_HI = 49
-pkg debug/elf, const R_PPC64_TOC16_HI R_PPC64
-pkg debug/elf, const R_PPC64_TOC16_LO = 48
-pkg debug/elf, const R_PPC64_TOC16_LO R_PPC64
-pkg debug/elf, const R_PPC64_TOC16_LO_DS = 64
-pkg debug/elf, const R_PPC64_TOC16_LO_DS R_PPC64
-pkg debug/elf, const R_PPC64_TPREL16 = 69
-pkg debug/elf, const R_PPC64_TPREL16 R_PPC64
-pkg debug/elf, const R_PPC64_TPREL16_DS = 95
-pkg debug/elf, const R_PPC64_TPREL16_DS R_PPC64
-pkg debug/elf, const R_PPC64_TPREL16_HA = 72
-pkg debug/elf, const R_PPC64_TPREL16_HA R_PPC64
-pkg debug/elf, const R_PPC64_TPREL16_HI = 71
-pkg debug/elf, const R_PPC64_TPREL16_HI R_PPC64
-pkg debug/elf, const R_PPC64_TPREL16_HIGHER = 97
-pkg debug/elf, const R_PPC64_TPREL16_HIGHER R_PPC64
-pkg debug/elf, const R_PPC64_TPREL16_HIGHERA = 98
-pkg debug/elf, const R_PPC64_TPREL16_HIGHERA R_PPC64
-pkg debug/elf, const R_PPC64_TPREL16_HIGHEST = 99
-pkg debug/elf, const R_PPC64_TPREL16_HIGHEST R_PPC64
-pkg debug/elf, const R_PPC64_TPREL16_HIGHESTA = 100
-pkg debug/elf, const R_PPC64_TPREL16_HIGHESTA R_PPC64
-pkg debug/elf, const R_PPC64_TPREL16_LO = 70
-pkg debug/elf, const R_PPC64_TPREL16_LO R_PPC64
-pkg debug/elf, const R_PPC64_TPREL16_LO_DS = 96
-pkg debug/elf, const R_PPC64_TPREL16_LO_DS R_PPC64
-pkg debug/elf, const R_PPC64_TPREL64 = 73
-pkg debug/elf, const R_PPC64_TPREL64 R_PPC64
-pkg debug/elf, method (R_PPC64) GoString() string
-pkg debug/elf, method (R_PPC64) String() string
-pkg debug/elf, type R_PPC64 int
-pkg encoding/base64, const NoPadding = -1
-pkg encoding/base64, const NoPadding int32
-pkg encoding/base64, const StdPadding = 61
-pkg encoding/base64, const StdPadding int32
-pkg encoding/base64, method (Encoding) WithPadding(int32) *Encoding
-pkg encoding/base64, var RawStdEncoding *Encoding
-pkg encoding/base64, var RawURLEncoding *Encoding
-pkg encoding/json, method (*Decoder) More() bool
-pkg encoding/json, method (*Decoder) Token() (Token, error)
-pkg encoding/json, method (Delim) String() string
-pkg encoding/json, type Delim int32
-pkg encoding/json, type Token interface {}
-pkg encoding/json, type UnmarshalTypeError struct, Offset int64
-pkg flag, func UnquoteUsage(*Flag) (string, string)
-pkg go/ast, type EmptyStmt struct, Implicit bool
-pkg go/build, type Package struct, PkgTargetRoot string
-pkg go/constant, const Bool = 1
-pkg go/constant, const Bool Kind
-pkg go/constant, const Complex = 5
-pkg go/constant, const Complex Kind
-pkg go/constant, const Float = 4
-pkg go/constant, const Float Kind
-pkg go/constant, const Int = 3
-pkg go/constant, const Int Kind
-pkg go/constant, const String = 2
-pkg go/constant, const String Kind
-pkg go/constant, const Unknown = 0
-pkg go/constant, const Unknown Kind
-pkg go/constant, func BinaryOp(Value, token.Token, Value) Value
-pkg go/constant, func BitLen(Value) int
-pkg go/constant, func BoolVal(Value) bool
-pkg go/constant, func Bytes(Value) []uint8
-pkg go/constant, func Compare(Value, token.Token, Value) bool
-pkg go/constant, func Denom(Value) Value
-pkg go/constant, func Float32Val(Value) (float32, bool)
-pkg go/constant, func Float64Val(Value) (float64, bool)
-pkg go/constant, func Imag(Value) Value
-pkg go/constant, func Int64Val(Value) (int64, bool)
-pkg go/constant, func MakeBool(bool) Value
-pkg go/constant, func MakeFloat64(float64) Value
-pkg go/constant, func MakeFromBytes([]uint8) Value
-pkg go/constant, func MakeFromLiteral(string, token.Token, uint) Value
-pkg go/constant, func MakeImag(Value) Value
-pkg go/constant, func MakeInt64(int64) Value
-pkg go/constant, func MakeString(string) Value
-pkg go/constant, func MakeUint64(uint64) Value
-pkg go/constant, func MakeUnknown() Value
-pkg go/constant, func Num(Value) Value
-pkg go/constant, func Real(Value) Value
-pkg go/constant, func Shift(Value, token.Token, uint) Value
-pkg go/constant, func Sign(Value) int
-pkg go/constant, func StringVal(Value) string
-pkg go/constant, func Uint64Val(Value) (uint64, bool)
-pkg go/constant, func UnaryOp(token.Token, Value, uint) Value
-pkg go/constant, type Kind int
-pkg go/constant, type Value interface, Kind() Kind
-pkg go/constant, type Value interface, String() string
-pkg go/constant, type Value interface, unexported methods
-pkg go/importer, func Default() types.Importer
-pkg go/importer, func For(string, Lookup) types.Importer
-pkg go/importer, type Lookup func(string) (io.ReadCloser, error)
-pkg go/parser, func ParseExprFrom(*token.FileSet, string, interface{}, Mode) (ast.Expr, error)
-pkg go/types, const Bool = 1
-pkg go/types, const Bool BasicKind
-pkg go/types, const Byte = 8
-pkg go/types, const Byte BasicKind
-pkg go/types, const Complex128 = 16
-pkg go/types, const Complex128 BasicKind
-pkg go/types, const Complex64 = 15
-pkg go/types, const Complex64 BasicKind
-pkg go/types, const FieldVal = 0
-pkg go/types, const FieldVal SelectionKind
-pkg go/types, const Float32 = 13
-pkg go/types, const Float32 BasicKind
-pkg go/types, const Float64 = 14
-pkg go/types, const Float64 BasicKind
-pkg go/types, const Int = 2
-pkg go/types, const Int BasicKind
-pkg go/types, const Int16 = 4
-pkg go/types, const Int16 BasicKind
-pkg go/types, const Int32 = 5
-pkg go/types, const Int32 BasicKind
-pkg go/types, const Int64 = 6
-pkg go/types, const Int64 BasicKind
-pkg go/types, const Int8 = 3
-pkg go/types, const Int8 BasicKind
-pkg go/types, const Invalid = 0
-pkg go/types, const Invalid BasicKind
-pkg go/types, const IsBoolean = 1
-pkg go/types, const IsBoolean BasicInfo
-pkg go/types, const IsComplex = 16
-pkg go/types, const IsComplex BasicInfo
-pkg go/types, const IsConstType = 59
-pkg go/types, const IsConstType BasicInfo
-pkg go/types, const IsFloat = 8
-pkg go/types, const IsFloat BasicInfo
-pkg go/types, const IsInteger = 2
-pkg go/types, const IsInteger BasicInfo
-pkg go/types, const IsNumeric = 26
-pkg go/types, const IsNumeric BasicInfo
-pkg go/types, const IsOrdered = 42
-pkg go/types, const IsOrdered BasicInfo
-pkg go/types, const IsString = 32
-pkg go/types, const IsString BasicInfo
-pkg go/types, const IsUnsigned = 4
-pkg go/types, const IsUnsigned BasicInfo
-pkg go/types, const IsUntyped = 64
-pkg go/types, const IsUntyped BasicInfo
-pkg go/types, const MethodExpr = 2
-pkg go/types, const MethodExpr SelectionKind
-pkg go/types, const MethodVal = 1
-pkg go/types, const MethodVal SelectionKind
-pkg go/types, const RecvOnly = 2
-pkg go/types, const RecvOnly ChanDir
-pkg go/types, const Rune = 5
-pkg go/types, const Rune BasicKind
-pkg go/types, const SendOnly = 1
-pkg go/types, const SendOnly ChanDir
-pkg go/types, const SendRecv = 0
-pkg go/types, const SendRecv ChanDir
-pkg go/types, const String = 17
-pkg go/types, const String BasicKind
-pkg go/types, const Uint = 7
-pkg go/types, const Uint BasicKind
-pkg go/types, const Uint16 = 9
-pkg go/types, const Uint16 BasicKind
-pkg go/types, const Uint32 = 10
-pkg go/types, const Uint32 BasicKind
-pkg go/types, const Uint64 = 11
-pkg go/types, const Uint64 BasicKind
-pkg go/types, const Uint8 = 8
-pkg go/types, const Uint8 BasicKind
-pkg go/types, const Uintptr = 12
-pkg go/types, const Uintptr BasicKind
-pkg go/types, const UnsafePointer = 18
-pkg go/types, const UnsafePointer BasicKind
-pkg go/types, const UntypedBool = 19
-pkg go/types, const UntypedBool BasicKind
-pkg go/types, const UntypedComplex = 23
-pkg go/types, const UntypedComplex BasicKind
-pkg go/types, const UntypedFloat = 22
-pkg go/types, const UntypedFloat BasicKind
-pkg go/types, const UntypedInt = 20
-pkg go/types, const UntypedInt BasicKind
-pkg go/types, const UntypedNil = 25
-pkg go/types, const UntypedNil BasicKind
-pkg go/types, const UntypedRune = 21
-pkg go/types, const UntypedRune BasicKind
-pkg go/types, const UntypedString = 24
-pkg go/types, const UntypedString BasicKind
-pkg go/types, func AssertableTo(*Interface, Type) bool
-pkg go/types, func AssignableTo(Type, Type) bool
-pkg go/types, func Comparable(Type) bool
-pkg go/types, func ConvertibleTo(Type, Type) bool
-pkg go/types, func DefPredeclaredTestFuncs()
-pkg go/types, func Eval(*token.FileSet, *Package, token.Pos, string) (TypeAndValue, error)
-pkg go/types, func ExprString(ast.Expr) string
-pkg go/types, func Id(*Package, string) string
-pkg go/types, func Identical(Type, Type) bool
-pkg go/types, func Implements(Type, *Interface) bool
-pkg go/types, func IsInterface(Type) bool
-pkg go/types, func LookupFieldOrMethod(Type, bool, *Package, string) (Object, []int, bool)
-pkg go/types, func MissingMethod(Type, *Interface, bool) (*Func, bool)
-pkg go/types, func NewArray(Type, int64) *Array
-pkg go/types, func NewChan(ChanDir, Type) *Chan
-pkg go/types, func NewChecker(*Config, *token.FileSet, *Package, *Info) *Checker
-pkg go/types, func NewConst(token.Pos, *Package, string, Type, constant.Value) *Const
-pkg go/types, func NewField(token.Pos, *Package, string, Type, bool) *Var
-pkg go/types, func NewFunc(token.Pos, *Package, string, *Signature) *Func
-pkg go/types, func NewInterface([]*Func, []*Named) *Interface
-pkg go/types, func NewLabel(token.Pos, *Package, string) *Label
-pkg go/types, func NewMap(Type, Type) *Map
-pkg go/types, func NewMethodSet(Type) *MethodSet
-pkg go/types, func NewNamed(*TypeName, Type, []*Func) *Named
-pkg go/types, func NewPackage(string, string) *Package
-pkg go/types, func NewParam(token.Pos, *Package, string, Type) *Var
-pkg go/types, func NewPkgName(token.Pos, *Package, string, *Package) *PkgName
-pkg go/types, func NewPointer(Type) *Pointer
-pkg go/types, func NewScope(*Scope, token.Pos, token.Pos, string) *Scope
-pkg go/types, func NewSignature(*Var, *Tuple, *Tuple, bool) *Signature
-pkg go/types, func NewSlice(Type) *Slice
-pkg go/types, func NewStruct([]*Var, []string) *Struct
-pkg go/types, func NewTuple(...*Var) *Tuple
-pkg go/types, func NewTypeName(token.Pos, *Package, string, Type) *TypeName
-pkg go/types, func NewVar(token.Pos, *Package, string, Type) *Var
-pkg go/types, func ObjectString(Object, Qualifier) string
-pkg go/types, func RelativeTo(*Package) Qualifier
-pkg go/types, func SelectionString(*Selection, Qualifier) string
-pkg go/types, func TypeString(Type, Qualifier) string
-pkg go/types, func WriteExpr(*bytes.Buffer, ast.Expr)
-pkg go/types, func WriteSignature(*bytes.Buffer, *Signature, Qualifier)
-pkg go/types, func WriteType(*bytes.Buffer, Type, Qualifier)
-pkg go/types, method (*Array) Elem() Type
-pkg go/types, method (*Array) Len() int64
-pkg go/types, method (*Array) String() string
-pkg go/types, method (*Array) Underlying() Type
-pkg go/types, method (*Basic) Info() BasicInfo
-pkg go/types, method (*Basic) Kind() BasicKind
-pkg go/types, method (*Basic) Name() string
-pkg go/types, method (*Basic) String() string
-pkg go/types, method (*Basic) Underlying() Type
-pkg go/types, method (*Builtin) Exported() bool
-pkg go/types, method (*Builtin) Id() string
-pkg go/types, method (*Builtin) Name() string
-pkg go/types, method (*Builtin) Parent() *Scope
-pkg go/types, method (*Builtin) Pkg() *Package
-pkg go/types, method (*Builtin) Pos() token.Pos
-pkg go/types, method (*Builtin) String() string
-pkg go/types, method (*Builtin) Type() Type
-pkg go/types, method (*Chan) Dir() ChanDir
-pkg go/types, method (*Chan) Elem() Type
-pkg go/types, method (*Chan) String() string
-pkg go/types, method (*Chan) Underlying() Type
-pkg go/types, method (*Checker) Files([]*ast.File) error
-pkg go/types, method (*Config) Check(string, *token.FileSet, []*ast.File, *Info) (*Package, error)
-pkg go/types, method (*Const) Exported() bool
-pkg go/types, method (*Const) Id() string
-pkg go/types, method (*Const) Name() string
-pkg go/types, method (*Const) Parent() *Scope
-pkg go/types, method (*Const) Pkg() *Package
-pkg go/types, method (*Const) Pos() token.Pos
-pkg go/types, method (*Const) String() string
-pkg go/types, method (*Const) Type() Type
-pkg go/types, method (*Const) Val() constant.Value
-pkg go/types, method (*Func) Exported() bool
-pkg go/types, method (*Func) FullName() string
-pkg go/types, method (*Func) Id() string
-pkg go/types, method (*Func) Name() string
-pkg go/types, method (*Func) Parent() *Scope
-pkg go/types, method (*Func) Pkg() *Package
-pkg go/types, method (*Func) Pos() token.Pos
-pkg go/types, method (*Func) Scope() *Scope
-pkg go/types, method (*Func) String() string
-pkg go/types, method (*Func) Type() Type
-pkg go/types, method (*Info) ObjectOf(*ast.Ident) Object
-pkg go/types, method (*Info) TypeOf(ast.Expr) Type
-pkg go/types, method (*Initializer) String() string
-pkg go/types, method (*Interface) Complete() *Interface
-pkg go/types, method (*Interface) Embedded(int) *Named
-pkg go/types, method (*Interface) Empty() bool
-pkg go/types, method (*Interface) ExplicitMethod(int) *Func
-pkg go/types, method (*Interface) Method(int) *Func
-pkg go/types, method (*Interface) NumEmbeddeds() int
-pkg go/types, method (*Interface) NumExplicitMethods() int
-pkg go/types, method (*Interface) NumMethods() int
-pkg go/types, method (*Interface) String() string
-pkg go/types, method (*Interface) Underlying() Type
-pkg go/types, method (*Label) Exported() bool
-pkg go/types, method (*Label) Id() string
-pkg go/types, method (*Label) Name() string
-pkg go/types, method (*Label) Parent() *Scope
-pkg go/types, method (*Label) Pkg() *Package
-pkg go/types, method (*Label) Pos() token.Pos
-pkg go/types, method (*Label) String() string
-pkg go/types, method (*Label) Type() Type
-pkg go/types, method (*Map) Elem() Type
-pkg go/types, method (*Map) Key() Type
-pkg go/types, method (*Map) String() string
-pkg go/types, method (*Map) Underlying() Type
-pkg go/types, method (*MethodSet) At(int) *Selection
-pkg go/types, method (*MethodSet) Len() int
-pkg go/types, method (*MethodSet) Lookup(*Package, string) *Selection
-pkg go/types, method (*MethodSet) String() string
-pkg go/types, method (*Named) AddMethod(*Func)
-pkg go/types, method (*Named) Method(int) *Func
-pkg go/types, method (*Named) NumMethods() int
-pkg go/types, method (*Named) Obj() *TypeName
-pkg go/types, method (*Named) SetUnderlying(Type)
-pkg go/types, method (*Named) String() string
-pkg go/types, method (*Named) Underlying() Type
-pkg go/types, method (*Nil) Exported() bool
-pkg go/types, method (*Nil) Id() string
-pkg go/types, method (*Nil) Name() string
-pkg go/types, method (*Nil) Parent() *Scope
-pkg go/types, method (*Nil) Pkg() *Package
-pkg go/types, method (*Nil) Pos() token.Pos
-pkg go/types, method (*Nil) String() string
-pkg go/types, method (*Nil) Type() Type
-pkg go/types, method (*Package) Complete() bool
-pkg go/types, method (*Package) Imports() []*Package
-pkg go/types, method (*Package) MarkComplete()
-pkg go/types, method (*Package) Name() string
-pkg go/types, method (*Package) Path() string
-pkg go/types, method (*Package) Scope() *Scope
-pkg go/types, method (*Package) SetImports([]*Package)
-pkg go/types, method (*Package) String() string
-pkg go/types, method (*PkgName) Exported() bool
-pkg go/types, method (*PkgName) Id() string
-pkg go/types, method (*PkgName) Imported() *Package
-pkg go/types, method (*PkgName) Name() string
-pkg go/types, method (*PkgName) Parent() *Scope
-pkg go/types, method (*PkgName) Pkg() *Package
-pkg go/types, method (*PkgName) Pos() token.Pos
-pkg go/types, method (*PkgName) String() string
-pkg go/types, method (*PkgName) Type() Type
-pkg go/types, method (*Pointer) Elem() Type
-pkg go/types, method (*Pointer) String() string
-pkg go/types, method (*Pointer) Underlying() Type
-pkg go/types, method (*Scope) Child(int) *Scope
-pkg go/types, method (*Scope) Contains(token.Pos) bool
-pkg go/types, method (*Scope) End() token.Pos
-pkg go/types, method (*Scope) Innermost(token.Pos) *Scope
-pkg go/types, method (*Scope) Insert(Object) Object
-pkg go/types, method (*Scope) Len() int
-pkg go/types, method (*Scope) Lookup(string) Object
-pkg go/types, method (*Scope) LookupParent(string, token.Pos) (*Scope, Object)
-pkg go/types, method (*Scope) Names() []string
-pkg go/types, method (*Scope) NumChildren() int
-pkg go/types, method (*Scope) Parent() *Scope
-pkg go/types, method (*Scope) Pos() token.Pos
-pkg go/types, method (*Scope) String() string
-pkg go/types, method (*Scope) WriteTo(io.Writer, int, bool)
-pkg go/types, method (*Selection) Index() []int
-pkg go/types, method (*Selection) Indirect() bool
-pkg go/types, method (*Selection) Kind() SelectionKind
-pkg go/types, method (*Selection) Obj() Object
-pkg go/types, method (*Selection) Recv() Type
-pkg go/types, method (*Selection) String() string
-pkg go/types, method (*Selection) Type() Type
-pkg go/types, method (*Signature) Params() *Tuple
-pkg go/types, method (*Signature) Recv() *Var
-pkg go/types, method (*Signature) Results() *Tuple
-pkg go/types, method (*Signature) String() string
-pkg go/types, method (*Signature) Underlying() Type
-pkg go/types, method (*Signature) Variadic() bool
-pkg go/types, method (*Slice) Elem() Type
-pkg go/types, method (*Slice) String() string
-pkg go/types, method (*Slice) Underlying() Type
-pkg go/types, method (*StdSizes) Alignof(Type) int64
-pkg go/types, method (*StdSizes) Offsetsof([]*Var) []int64
-pkg go/types, method (*StdSizes) Sizeof(Type) int64
-pkg go/types, method (*Struct) Field(int) *Var
-pkg go/types, method (*Struct) NumFields() int
-pkg go/types, method (*Struct) String() string
-pkg go/types, method (*Struct) Tag(int) string
-pkg go/types, method (*Struct) Underlying() Type
-pkg go/types, method (*Tuple) At(int) *Var
-pkg go/types, method (*Tuple) Len() int
-pkg go/types, method (*Tuple) String() string
-pkg go/types, method (*Tuple) Underlying() Type
-pkg go/types, method (*TypeName) Exported() bool
-pkg go/types, method (*TypeName) Id() string
-pkg go/types, method (*TypeName) Name() string
-pkg go/types, method (*TypeName) Parent() *Scope
-pkg go/types, method (*TypeName) Pkg() *Package
-pkg go/types, method (*TypeName) Pos() token.Pos
-pkg go/types, method (*TypeName) String() string
-pkg go/types, method (*TypeName) Type() Type
-pkg go/types, method (*Var) Anonymous() bool
-pkg go/types, method (*Var) Exported() bool
-pkg go/types, method (*Var) Id() string
-pkg go/types, method (*Var) IsField() bool
-pkg go/types, method (*Var) Name() string
-pkg go/types, method (*Var) Parent() *Scope
-pkg go/types, method (*Var) Pkg() *Package
-pkg go/types, method (*Var) Pos() token.Pos
-pkg go/types, method (*Var) String() string
-pkg go/types, method (*Var) Type() Type
-pkg go/types, method (Checker) ObjectOf(*ast.Ident) Object
-pkg go/types, method (Checker) TypeOf(ast.Expr) Type
-pkg go/types, method (Error) Error() string
-pkg go/types, method (TypeAndValue) Addressable() bool
-pkg go/types, method (TypeAndValue) Assignable() bool
-pkg go/types, method (TypeAndValue) HasOk() bool
-pkg go/types, method (TypeAndValue) IsBuiltin() bool
-pkg go/types, method (TypeAndValue) IsNil() bool
-pkg go/types, method (TypeAndValue) IsType() bool
-pkg go/types, method (TypeAndValue) IsValue() bool
-pkg go/types, method (TypeAndValue) IsVoid() bool
-pkg go/types, type Array struct
-pkg go/types, type Basic struct
-pkg go/types, type BasicInfo int
-pkg go/types, type BasicKind int
-pkg go/types, type Builtin struct
-pkg go/types, type Chan struct
-pkg go/types, type ChanDir int
-pkg go/types, type Checker struct
-pkg go/types, type Checker struct, embedded *Info
-pkg go/types, type Config struct
-pkg go/types, type Config struct, DisableUnusedImportCheck bool
-pkg go/types, type Config struct, Error func(error)
-pkg go/types, type Config struct, FakeImportC bool
-pkg go/types, type Config struct, IgnoreFuncBodies bool
-pkg go/types, type Config struct, Importer Importer
-pkg go/types, type Config struct, Sizes Sizes
-pkg go/types, type Const struct
-pkg go/types, type Error struct
-pkg go/types, type Error struct, Fset *token.FileSet
-pkg go/types, type Error struct, Msg string
-pkg go/types, type Error struct, Pos token.Pos
-pkg go/types, type Error struct, Soft bool
-pkg go/types, type Func struct
-pkg go/types, type Importer interface { Import }
-pkg go/types, type Importer interface, Import(string) (*Package, error)
-pkg go/types, type Info struct
-pkg go/types, type Info struct, Defs map[*ast.Ident]Object
-pkg go/types, type Info struct, Implicits map[ast.Node]Object
-pkg go/types, type Info struct, InitOrder []*Initializer
-pkg go/types, type Info struct, Scopes map[ast.Node]*Scope
-pkg go/types, type Info struct, Selections map[*ast.SelectorExpr]*Selection
-pkg go/types, type Info struct, Types map[ast.Expr]TypeAndValue
-pkg go/types, type Info struct, Uses map[*ast.Ident]Object
-pkg go/types, type Initializer struct
-pkg go/types, type Initializer struct, Lhs []*Var
-pkg go/types, type Initializer struct, Rhs ast.Expr
-pkg go/types, type Interface struct
-pkg go/types, type Label struct
-pkg go/types, type Map struct
-pkg go/types, type MethodSet struct
-pkg go/types, type Named struct
-pkg go/types, type Nil struct
-pkg go/types, type Object interface, Exported() bool
-pkg go/types, type Object interface, Id() string
-pkg go/types, type Object interface, Name() string
-pkg go/types, type Object interface, Parent() *Scope
-pkg go/types, type Object interface, Pkg() *Package
-pkg go/types, type Object interface, Pos() token.Pos
-pkg go/types, type Object interface, String() string
-pkg go/types, type Object interface, Type() Type
-pkg go/types, type Object interface, unexported methods
-pkg go/types, type Package struct
-pkg go/types, type PkgName struct
-pkg go/types, type Pointer struct
-pkg go/types, type Qualifier func(*Package) string
-pkg go/types, type Scope struct
-pkg go/types, type Selection struct
-pkg go/types, type SelectionKind int
-pkg go/types, type Signature struct
-pkg go/types, type Sizes interface { Alignof, Offsetsof, Sizeof }
-pkg go/types, type Sizes interface, Alignof(Type) int64
-pkg go/types, type Sizes interface, Offsetsof([]*Var) []int64
-pkg go/types, type Sizes interface, Sizeof(Type) int64
-pkg go/types, type Slice struct
-pkg go/types, type StdSizes struct
-pkg go/types, type StdSizes struct, MaxAlign int64
-pkg go/types, type StdSizes struct, WordSize int64
-pkg go/types, type Struct struct
-pkg go/types, type Tuple struct
-pkg go/types, type Type interface { String, Underlying }
-pkg go/types, type Type interface, String() string
-pkg go/types, type Type interface, Underlying() Type
-pkg go/types, type TypeAndValue struct
-pkg go/types, type TypeAndValue struct, Type Type
-pkg go/types, type TypeAndValue struct, Value constant.Value
-pkg go/types, type TypeName struct
-pkg go/types, type Var struct
-pkg go/types, var Typ []*Basic
-pkg go/types, var Universe *Scope
-pkg go/types, var Unsafe *Package
-pkg html/template, method (*Template) Option(...string) *Template
-pkg image, const YCbCrSubsampleRatio410 = 5
-pkg image, const YCbCrSubsampleRatio410 YCbCrSubsampleRatio
-pkg image, const YCbCrSubsampleRatio411 = 4
-pkg image, const YCbCrSubsampleRatio411 YCbCrSubsampleRatio
-pkg image, func NewCMYK(Rectangle) *CMYK
-pkg image, method (*CMYK) At(int, int) color.Color
-pkg image, method (*CMYK) Bounds() Rectangle
-pkg image, method (*CMYK) CMYKAt(int, int) color.CMYK
-pkg image, method (*CMYK) ColorModel() color.Model
-pkg image, method (*CMYK) Opaque() bool
-pkg image, method (*CMYK) PixOffset(int, int) int
-pkg image, method (*CMYK) Set(int, int, color.Color)
-pkg image, method (*CMYK) SetCMYK(int, int, color.CMYK)
-pkg image, method (*CMYK) SubImage(Rectangle) Image
-pkg image, method (Rectangle) At(int, int) color.Color
-pkg image, method (Rectangle) Bounds() Rectangle
-pkg image, method (Rectangle) ColorModel() color.Model
-pkg image, type CMYK struct
-pkg image, type CMYK struct, Pix []uint8
-pkg image, type CMYK struct, Rect Rectangle
-pkg image, type CMYK struct, Stride int
-pkg image/color, func CMYKToRGB(uint8, uint8, uint8, uint8) (uint8, uint8, uint8)
-pkg image/color, func RGBToCMYK(uint8, uint8, uint8) (uint8, uint8, uint8, uint8)
-pkg image/color, method (CMYK) RGBA() (uint32, uint32, uint32, uint32)
-pkg image/color, type CMYK struct
-pkg image/color, type CMYK struct, C uint8
-pkg image/color, type CMYK struct, K uint8
-pkg image/color, type CMYK struct, M uint8
-pkg image/color, type CMYK struct, Y uint8
-pkg image/color, var CMYKModel Model
-pkg image/gif, const DisposalBackground = 2
-pkg image/gif, const DisposalBackground ideal-int
-pkg image/gif, const DisposalNone = 1
-pkg image/gif, const DisposalNone ideal-int
-pkg image/gif, const DisposalPrevious = 3
-pkg image/gif, const DisposalPrevious ideal-int
-pkg image/gif, type GIF struct, BackgroundIndex uint8
-pkg image/gif, type GIF struct, Config image.Config
-pkg image/gif, type GIF struct, Disposal []uint8
-pkg io, func CopyBuffer(Writer, Reader, []uint8) (int64, error)
-pkg log, const LUTC = 32
-pkg log, const LUTC ideal-int
-pkg log, func Output(int, string) error
-pkg log, method (*Logger) SetOutput(io.Writer)
-pkg math/big, const Above = 1
-pkg math/big, const Above Accuracy
-pkg math/big, const AwayFromZero = 3
-pkg math/big, const AwayFromZero RoundingMode
-pkg math/big, const Below = -1
-pkg math/big, const Below Accuracy
-pkg math/big, const Exact = 0
-pkg math/big, const Exact Accuracy
-pkg math/big, const MaxExp = 2147483647
-pkg math/big, const MaxExp ideal-int
-pkg math/big, const MaxPrec = 4294967295
-pkg math/big, const MaxPrec ideal-int
-pkg math/big, const MinExp = -2147483648
-pkg math/big, const MinExp ideal-int
-pkg math/big, const ToNearestAway = 1
-pkg math/big, const ToNearestAway RoundingMode
-pkg math/big, const ToNearestEven = 0
-pkg math/big, const ToNearestEven RoundingMode
-pkg math/big, const ToNegativeInf = 4
-pkg math/big, const ToNegativeInf RoundingMode
-pkg math/big, const ToPositiveInf = 5
-pkg math/big, const ToPositiveInf RoundingMode
-pkg math/big, const ToZero = 2
-pkg math/big, const ToZero RoundingMode
-pkg math/big, func Jacobi(*Int, *Int) int
-pkg math/big, func NewFloat(float64) *Float
-pkg math/big, func ParseFloat(string, int, uint, RoundingMode) (*Float, int, error)
-pkg math/big, method (*Float) Abs(*Float) *Float
-pkg math/big, method (*Float) Acc() Accuracy
-pkg math/big, method (*Float) Add(*Float, *Float) *Float
-pkg math/big, method (*Float) Append([]uint8, uint8, int) []uint8
-pkg math/big, method (*Float) Cmp(*Float) int
-pkg math/big, method (*Float) Copy(*Float) *Float
-pkg math/big, method (*Float) Float32() (float32, Accuracy)
-pkg math/big, method (*Float) Float64() (float64, Accuracy)
-pkg math/big, method (*Float) Format(fmt.State, int32)
-pkg math/big, method (*Float) Int(*Int) (*Int, Accuracy)
-pkg math/big, method (*Float) Int64() (int64, Accuracy)
-pkg math/big, method (*Float) IsInf() bool
-pkg math/big, method (*Float) IsInt() bool
-pkg math/big, method (*Float) MantExp(*Float) int
-pkg math/big, method (*Float) MinPrec() uint
-pkg math/big, method (*Float) Mode() RoundingMode
-pkg math/big, method (*Float) Mul(*Float, *Float) *Float
-pkg math/big, method (*Float) Neg(*Float) *Float
-pkg math/big, method (*Float) Parse(string, int) (*Float, int, error)
-pkg math/big, method (*Float) Prec() uint
-pkg math/big, method (*Float) Quo(*Float, *Float) *Float
-pkg math/big, method (*Float) Rat(*Rat) (*Rat, Accuracy)
-pkg math/big, method (*Float) Set(*Float) *Float
-pkg math/big, method (*Float) SetFloat64(float64) *Float
-pkg math/big, method (*Float) SetInf(bool) *Float
-pkg math/big, method (*Float) SetInt(*Int) *Float
-pkg math/big, method (*Float) SetInt64(int64) *Float
-pkg math/big, method (*Float) SetMantExp(*Float, int) *Float
-pkg math/big, method (*Float) SetMode(RoundingMode) *Float
-pkg math/big, method (*Float) SetPrec(uint) *Float
-pkg math/big, method (*Float) SetRat(*Rat) *Float
-pkg math/big, method (*Float) SetString(string) (*Float, bool)
-pkg math/big, method (*Float) SetUint64(uint64) *Float
-pkg math/big, method (*Float) Sign() int
-pkg math/big, method (*Float) Signbit() bool
-pkg math/big, method (*Float) String() string
-pkg math/big, method (*Float) Sub(*Float, *Float) *Float
-pkg math/big, method (*Float) Text(uint8, int) string
-pkg math/big, method (*Float) Uint64() (uint64, Accuracy)
-pkg math/big, method (*Int) ModSqrt(*Int, *Int) *Int
-pkg math/big, method (Accuracy) String() string
-pkg math/big, method (ErrNaN) Error() string
-pkg math/big, method (RoundingMode) String() string
-pkg math/big, type Accuracy int8
-pkg math/big, type ErrNaN struct
-pkg math/big, type Float struct
-pkg math/big, type RoundingMode uint8
-pkg mime, const BEncoding = 98
-pkg mime, const BEncoding WordEncoder
-pkg mime, const QEncoding = 113
-pkg mime, const QEncoding WordEncoder
-pkg mime, func ExtensionsByType(string) ([]string, error)
-pkg mime, method (*WordDecoder) Decode(string) (string, error)
-pkg mime, method (*WordDecoder) DecodeHeader(string) (string, error)
-pkg mime, method (WordEncoder) Encode(string, string) string
-pkg mime, type WordDecoder struct
-pkg mime, type WordDecoder struct, CharsetReader func(string, io.Reader) (io.Reader, error)
-pkg mime, type WordEncoder uint8
-pkg mime/quotedprintable, func NewReader(io.Reader) *Reader
-pkg mime/quotedprintable, func NewWriter(io.Writer) *Writer
-pkg mime/quotedprintable, method (*Reader) Read([]uint8) (int, error)
-pkg mime/quotedprintable, method (*Writer) Close() error
-pkg mime/quotedprintable, method (*Writer) Write([]uint8) (int, error)
-pkg mime/quotedprintable, type Reader struct
-pkg mime/quotedprintable, type Writer struct
-pkg mime/quotedprintable, type Writer struct, Binary bool
-pkg net, type Dialer struct, FallbackDelay time.Duration
-pkg net, type OpError struct, Source Addr
-pkg net/http, type Request struct, Cancel <-chan struct
-pkg net/http/fcgi, var ErrConnClosed error
-pkg net/http/fcgi, var ErrRequestAborted error
-pkg net/http/pprof, func Trace(http.ResponseWriter, *http.Request)
-pkg net/mail, method (*AddressParser) Parse(string) (*Address, error)
-pkg net/mail, method (*AddressParser) ParseList(string) ([]*Address, error)
-pkg net/mail, type AddressParser struct
-pkg net/mail, type AddressParser struct, WordDecoder *mime.WordDecoder
-pkg net/smtp, method (*Client) TLSConnectionState() (tls.ConnectionState, bool)
-pkg net/url, method (*URL) EscapedPath() string
-pkg net/url, type URL struct, RawPath string
-pkg os, func LookupEnv(string) (string, bool)
-pkg os/signal, func Ignore(...os.Signal)
-pkg os/signal, func Reset(...os.Signal)
-pkg reflect, func ArrayOf(int, Type) Type
-pkg reflect, func FuncOf([]Type, []Type, bool) Type
-pkg runtime, func ReadTrace() []uint8
-pkg runtime, func StartTrace() error
-pkg runtime, func StopTrace()
-pkg runtime, type MemStats struct, GCCPUFraction float64
-pkg runtime/trace, func Start(io.Writer) error
-pkg runtime/trace, func Stop()
-pkg strings, func Compare(string, string) int
-pkg strings, func LastIndexByte(string, uint8) int
-pkg strings, method (*Reader) Size() int64
-pkg syscall (darwin-386), type SysProcAttr struct, Ctty int
-pkg syscall (darwin-386), type SysProcAttr struct, Foreground bool
-pkg syscall (darwin-386), type SysProcAttr struct, Pgid int
-pkg syscall (darwin-386-cgo), type SysProcAttr struct, Ctty int
-pkg syscall (darwin-386-cgo), type SysProcAttr struct, Foreground bool
-pkg syscall (darwin-386-cgo), type SysProcAttr struct, Pgid int
-pkg syscall (darwin-amd64), type SysProcAttr struct, Ctty int
-pkg syscall (darwin-amd64), type SysProcAttr struct, Foreground bool
-pkg syscall (darwin-amd64), type SysProcAttr struct, Pgid int
-pkg syscall (darwin-amd64-cgo), type SysProcAttr struct, Ctty int
-pkg syscall (darwin-amd64-cgo), type SysProcAttr struct, Foreground bool
-pkg syscall (darwin-amd64-cgo), type SysProcAttr struct, Pgid int
-pkg syscall (freebsd-386), type SysProcAttr struct, Ctty int
-pkg syscall (freebsd-386), type SysProcAttr struct, Foreground bool
-pkg syscall (freebsd-386), type SysProcAttr struct, Pgid int
-pkg syscall (freebsd-386-cgo), type SysProcAttr struct, Ctty int
-pkg syscall (freebsd-386-cgo), type SysProcAttr struct, Foreground bool
-pkg syscall (freebsd-386-cgo), type SysProcAttr struct, Pgid int
-pkg syscall (freebsd-amd64), type SysProcAttr struct, Ctty int
-pkg syscall (freebsd-amd64), type SysProcAttr struct, Foreground bool
-pkg syscall (freebsd-amd64), type SysProcAttr struct, Pgid int
-pkg syscall (freebsd-amd64-cgo), type SysProcAttr struct, Ctty int
-pkg syscall (freebsd-amd64-cgo), type SysProcAttr struct, Foreground bool
-pkg syscall (freebsd-amd64-cgo), type SysProcAttr struct, Pgid int
-pkg syscall (freebsd-arm), type SysProcAttr struct, Ctty int
-pkg syscall (freebsd-arm), type SysProcAttr struct, Foreground bool
-pkg syscall (freebsd-arm), type SysProcAttr struct, Pgid int
-pkg syscall (freebsd-arm-cgo), type SysProcAttr struct, Ctty int
-pkg syscall (freebsd-arm-cgo), type SysProcAttr struct, Foreground bool
-pkg syscall (freebsd-arm-cgo), type SysProcAttr struct, Pgid int
-pkg syscall (linux-386), type SysProcAttr struct, Foreground bool
-pkg syscall (linux-386), type SysProcAttr struct, GidMappingsEnableSetgroups bool
-pkg syscall (linux-386), type SysProcAttr struct, Pgid int
-pkg syscall (linux-386-cgo), type SysProcAttr struct, Foreground bool
-pkg syscall (linux-386-cgo), type SysProcAttr struct, GidMappingsEnableSetgroups bool
-pkg syscall (linux-386-cgo), type SysProcAttr struct, Pgid int
-pkg syscall (linux-amd64), type SysProcAttr struct, Foreground bool
-pkg syscall (linux-amd64), type SysProcAttr struct, GidMappingsEnableSetgroups bool
-pkg syscall (linux-amd64), type SysProcAttr struct, Pgid int
-pkg syscall (linux-amd64-cgo), type SysProcAttr struct, Foreground bool
-pkg syscall (linux-amd64-cgo), type SysProcAttr struct, GidMappingsEnableSetgroups bool
-pkg syscall (linux-amd64-cgo), type SysProcAttr struct, Pgid int
-pkg syscall (linux-arm), type SysProcAttr struct, Foreground bool
-pkg syscall (linux-arm), type SysProcAttr struct, GidMappingsEnableSetgroups bool
-pkg syscall (linux-arm), type SysProcAttr struct, Pgid int
-pkg syscall (linux-arm-cgo), type SysProcAttr struct, Foreground bool
-pkg syscall (linux-arm-cgo), type SysProcAttr struct, GidMappingsEnableSetgroups bool
-pkg syscall (linux-arm-cgo), type SysProcAttr struct, Pgid int
-pkg syscall (netbsd-386), type SysProcAttr struct, Ctty int
-pkg syscall (netbsd-386), type SysProcAttr struct, Foreground bool
-pkg syscall (netbsd-386), type SysProcAttr struct, Pgid int
-pkg syscall (netbsd-386-cgo), type SysProcAttr struct, Ctty int
-pkg syscall (netbsd-386-cgo), type SysProcAttr struct, Foreground bool
-pkg syscall (netbsd-386-cgo), type SysProcAttr struct, Pgid int
-pkg syscall (netbsd-amd64), type SysProcAttr struct, Ctty int
-pkg syscall (netbsd-amd64), type SysProcAttr struct, Foreground bool
-pkg syscall (netbsd-amd64), type SysProcAttr struct, Pgid int
-pkg syscall (netbsd-amd64-cgo), type SysProcAttr struct, Ctty int
-pkg syscall (netbsd-amd64-cgo), type SysProcAttr struct, Foreground bool
-pkg syscall (netbsd-amd64-cgo), type SysProcAttr struct, Pgid int
-pkg syscall (netbsd-arm), type SysProcAttr struct, Ctty int
-pkg syscall (netbsd-arm), type SysProcAttr struct, Foreground bool
-pkg syscall (netbsd-arm), type SysProcAttr struct, Pgid int
-pkg syscall (netbsd-arm-cgo), type SysProcAttr struct, Ctty int
-pkg syscall (netbsd-arm-cgo), type SysProcAttr struct, Foreground bool
-pkg syscall (netbsd-arm-cgo), type SysProcAttr struct, Pgid int
-pkg syscall (openbsd-386), type SysProcAttr struct, Ctty int
-pkg syscall (openbsd-386), type SysProcAttr struct, Foreground bool
-pkg syscall (openbsd-386), type SysProcAttr struct, Pgid int
-pkg syscall (openbsd-386-cgo), type SysProcAttr struct, Ctty int
-pkg syscall (openbsd-386-cgo), type SysProcAttr struct, Foreground bool
-pkg syscall (openbsd-386-cgo), type SysProcAttr struct, Pgid int
-pkg syscall (openbsd-amd64), type SysProcAttr struct, Ctty int
-pkg syscall (openbsd-amd64), type SysProcAttr struct, Foreground bool
-pkg syscall (openbsd-amd64), type SysProcAttr struct, Pgid int
-pkg syscall (openbsd-amd64-cgo), type SysProcAttr struct, Ctty int
-pkg syscall (openbsd-amd64-cgo), type SysProcAttr struct, Foreground bool
-pkg syscall (openbsd-amd64-cgo), type SysProcAttr struct, Pgid int
-pkg text/template, method (*Template) DefinedTemplates() string
-pkg text/template, method (*Template) Option(...string) *Template
-pkg time, method (Time) AppendFormat([]uint8, string) []uint8
-pkg unicode, const Version = "8.0.0"
-pkg unicode, var Ahom *RangeTable
-pkg unicode, var Anatolian_Hieroglyphs *RangeTable
-pkg unicode, var Hatran *RangeTable
-pkg unicode, var Multani *RangeTable
-pkg unicode, var Old_Hungarian *RangeTable
-pkg unicode, var SignWriting *RangeTable
--- a/api/go1.6.txt
+++ b/api/go1.6.txt
@@ -1,275 +0,0 @@
-pkg archive/zip, method (*ReadCloser) RegisterDecompressor(uint16, Decompressor)
-pkg archive/zip, method (*Reader) RegisterDecompressor(uint16, Decompressor)
-pkg archive/zip, method (*Writer) RegisterCompressor(uint16, Compressor)
-pkg bufio, method (*Scanner) Buffer([]uint8, int)
-pkg bufio, var ErrFinalToken error
-pkg crypto/tls, const TLS_RSA_WITH_AES_128_GCM_SHA256 = 156
-pkg crypto/tls, const TLS_RSA_WITH_AES_128_GCM_SHA256 uint16
-pkg crypto/tls, const TLS_RSA_WITH_AES_256_GCM_SHA384 = 157
-pkg crypto/tls, const TLS_RSA_WITH_AES_256_GCM_SHA384 uint16
-pkg crypto/tls, method (RecordHeaderError) Error() string
-pkg crypto/tls, type RecordHeaderError struct
-pkg crypto/tls, type RecordHeaderError struct, Msg string
-pkg crypto/tls, type RecordHeaderError struct, RecordHeader [5]uint8
-pkg crypto/x509, method (InsecureAlgorithmError) Error() string
-pkg crypto/x509, method (SignatureAlgorithm) String() string
-pkg crypto/x509, type InsecureAlgorithmError int
-pkg database/sql, method (*DB) SetConnMaxLifetime(time.Duration)
-pkg debug/dwarf, const ClassUnknown = 0
-pkg debug/dwarf, const ClassUnknown Class
-pkg debug/elf, const COMPRESS_HIOS = 1879048191
-pkg debug/elf, const COMPRESS_HIOS CompressionType
-pkg debug/elf, const COMPRESS_HIPROC = 2147483647
-pkg debug/elf, const COMPRESS_HIPROC CompressionType
-pkg debug/elf, const COMPRESS_LOOS = 1610612736
-pkg debug/elf, const COMPRESS_LOOS CompressionType
-pkg debug/elf, const COMPRESS_LOPROC = 1879048192
-pkg debug/elf, const COMPRESS_LOPROC CompressionType
-pkg debug/elf, const COMPRESS_ZLIB = 1
-pkg debug/elf, const COMPRESS_ZLIB CompressionType
-pkg debug/elf, const R_MIPS_16 = 1
-pkg debug/elf, const R_MIPS_16 R_MIPS
-pkg debug/elf, const R_MIPS_26 = 4
-pkg debug/elf, const R_MIPS_26 R_MIPS
-pkg debug/elf, const R_MIPS_32 = 2
-pkg debug/elf, const R_MIPS_32 R_MIPS
-pkg debug/elf, const R_MIPS_64 = 18
-pkg debug/elf, const R_MIPS_64 R_MIPS
-pkg debug/elf, const R_MIPS_ADD_IMMEDIATE = 34
-pkg debug/elf, const R_MIPS_ADD_IMMEDIATE R_MIPS
-pkg debug/elf, const R_MIPS_CALL16 = 11
-pkg debug/elf, const R_MIPS_CALL16 R_MIPS
-pkg debug/elf, const R_MIPS_CALL_HI16 = 30
-pkg debug/elf, const R_MIPS_CALL_HI16 R_MIPS
-pkg debug/elf, const R_MIPS_CALL_LO16 = 31
-pkg debug/elf, const R_MIPS_CALL_LO16 R_MIPS
-pkg debug/elf, const R_MIPS_DELETE = 27
-pkg debug/elf, const R_MIPS_DELETE R_MIPS
-pkg debug/elf, const R_MIPS_GOT16 = 9
-pkg debug/elf, const R_MIPS_GOT16 R_MIPS
-pkg debug/elf, const R_MIPS_GOT_DISP = 19
-pkg debug/elf, const R_MIPS_GOT_DISP R_MIPS
-pkg debug/elf, const R_MIPS_GOT_HI16 = 22
-pkg debug/elf, const R_MIPS_GOT_HI16 R_MIPS
-pkg debug/elf, const R_MIPS_GOT_LO16 = 23
-pkg debug/elf, const R_MIPS_GOT_LO16 R_MIPS
-pkg debug/elf, const R_MIPS_GOT_OFST = 21
-pkg debug/elf, const R_MIPS_GOT_OFST R_MIPS
-pkg debug/elf, const R_MIPS_GOT_PAGE = 20
-pkg debug/elf, const R_MIPS_GOT_PAGE R_MIPS
-pkg debug/elf, const R_MIPS_GPREL16 = 7
-pkg debug/elf, const R_MIPS_GPREL16 R_MIPS
-pkg debug/elf, const R_MIPS_GPREL32 = 12
-pkg debug/elf, const R_MIPS_GPREL32 R_MIPS
-pkg debug/elf, const R_MIPS_HI16 = 5
-pkg debug/elf, const R_MIPS_HI16 R_MIPS
-pkg debug/elf, const R_MIPS_HIGHER = 28
-pkg debug/elf, const R_MIPS_HIGHER R_MIPS
-pkg debug/elf, const R_MIPS_HIGHEST = 29
-pkg debug/elf, const R_MIPS_HIGHEST R_MIPS
-pkg debug/elf, const R_MIPS_INSERT_A = 25
-pkg debug/elf, const R_MIPS_INSERT_A R_MIPS
-pkg debug/elf, const R_MIPS_INSERT_B = 26
-pkg debug/elf, const R_MIPS_INSERT_B R_MIPS
-pkg debug/elf, const R_MIPS_JALR = 37
-pkg debug/elf, const R_MIPS_JALR R_MIPS
-pkg debug/elf, const R_MIPS_LITERAL = 8
-pkg debug/elf, const R_MIPS_LITERAL R_MIPS
-pkg debug/elf, const R_MIPS_LO16 = 6
-pkg debug/elf, const R_MIPS_LO16 R_MIPS
-pkg debug/elf, const R_MIPS_NONE = 0
-pkg debug/elf, const R_MIPS_NONE R_MIPS
-pkg debug/elf, const R_MIPS_PC16 = 10
-pkg debug/elf, const R_MIPS_PC16 R_MIPS
-pkg debug/elf, const R_MIPS_PJUMP = 35
-pkg debug/elf, const R_MIPS_PJUMP R_MIPS
-pkg debug/elf, const R_MIPS_REL16 = 33
-pkg debug/elf, const R_MIPS_REL16 R_MIPS
-pkg debug/elf, const R_MIPS_REL32 = 3
-pkg debug/elf, const R_MIPS_REL32 R_MIPS
-pkg debug/elf, const R_MIPS_RELGOT = 36
-pkg debug/elf, const R_MIPS_RELGOT R_MIPS
-pkg debug/elf, const R_MIPS_SCN_DISP = 32
-pkg debug/elf, const R_MIPS_SCN_DISP R_MIPS
-pkg debug/elf, const R_MIPS_SHIFT5 = 16
-pkg debug/elf, const R_MIPS_SHIFT5 R_MIPS
-pkg debug/elf, const R_MIPS_SHIFT6 = 17
-pkg debug/elf, const R_MIPS_SHIFT6 R_MIPS
-pkg debug/elf, const R_MIPS_SUB = 24
-pkg debug/elf, const R_MIPS_SUB R_MIPS
-pkg debug/elf, const R_MIPS_TLS_DTPMOD32 = 38
-pkg debug/elf, const R_MIPS_TLS_DTPMOD32 R_MIPS
-pkg debug/elf, const R_MIPS_TLS_DTPMOD64 = 40
-pkg debug/elf, const R_MIPS_TLS_DTPMOD64 R_MIPS
-pkg debug/elf, const R_MIPS_TLS_DTPREL32 = 39
-pkg debug/elf, const R_MIPS_TLS_DTPREL32 R_MIPS
-pkg debug/elf, const R_MIPS_TLS_DTPREL64 = 41
-pkg debug/elf, const R_MIPS_TLS_DTPREL64 R_MIPS
-pkg debug/elf, const R_MIPS_TLS_DTPREL_HI16 = 44
-pkg debug/elf, const R_MIPS_TLS_DTPREL_HI16 R_MIPS
-pkg debug/elf, const R_MIPS_TLS_DTPREL_LO16 = 45
-pkg debug/elf, const R_MIPS_TLS_DTPREL_LO16 R_MIPS
-pkg debug/elf, const R_MIPS_TLS_GD = 42
-pkg debug/elf, const R_MIPS_TLS_GD R_MIPS
-pkg debug/elf, const R_MIPS_TLS_GOTTPREL = 46
-pkg debug/elf, const R_MIPS_TLS_GOTTPREL R_MIPS
-pkg debug/elf, const R_MIPS_TLS_LDM = 43
-pkg debug/elf, const R_MIPS_TLS_LDM R_MIPS
-pkg debug/elf, const R_MIPS_TLS_TPREL32 = 47
-pkg debug/elf, const R_MIPS_TLS_TPREL32 R_MIPS
-pkg debug/elf, const R_MIPS_TLS_TPREL64 = 48
-pkg debug/elf, const R_MIPS_TLS_TPREL64 R_MIPS
-pkg debug/elf, const R_MIPS_TLS_TPREL_HI16 = 49
-pkg debug/elf, const R_MIPS_TLS_TPREL_HI16 R_MIPS
-pkg debug/elf, const R_MIPS_TLS_TPREL_LO16 = 50
-pkg debug/elf, const R_MIPS_TLS_TPREL_LO16 R_MIPS
-pkg debug/elf, const SHF_COMPRESSED = 2048
-pkg debug/elf, const SHF_COMPRESSED SectionFlag
-pkg debug/elf, method (CompressionType) GoString() string
-pkg debug/elf, method (CompressionType) String() string
-pkg debug/elf, method (R_MIPS) GoString() string
-pkg debug/elf, method (R_MIPS) String() string
-pkg debug/elf, type Chdr32 struct
-pkg debug/elf, type Chdr32 struct, Addralign uint32
-pkg debug/elf, type Chdr32 struct, Size uint32
-pkg debug/elf, type Chdr32 struct, Type uint32
-pkg debug/elf, type Chdr64 struct
-pkg debug/elf, type Chdr64 struct, Addralign uint64
-pkg debug/elf, type Chdr64 struct, Size uint64
-pkg debug/elf, type Chdr64 struct, Type uint32
-pkg debug/elf, type CompressionType int
-pkg debug/elf, type R_MIPS int
-pkg debug/elf, type SectionHeader struct, FileSize uint64
-pkg encoding/asn1, const ClassApplication = 1
-pkg encoding/asn1, const ClassApplication ideal-int
-pkg encoding/asn1, const ClassContextSpecific = 2
-pkg encoding/asn1, const ClassContextSpecific ideal-int
-pkg encoding/asn1, const ClassPrivate = 3
-pkg encoding/asn1, const ClassPrivate ideal-int
-pkg encoding/asn1, const ClassUniversal = 0
-pkg encoding/asn1, const ClassUniversal ideal-int
-pkg encoding/asn1, const TagBitString = 3
-pkg encoding/asn1, const TagBitString ideal-int
-pkg encoding/asn1, const TagBoolean = 1
-pkg encoding/asn1, const TagBoolean ideal-int
-pkg encoding/asn1, const TagEnum = 10
-pkg encoding/asn1, const TagEnum ideal-int
-pkg encoding/asn1, const TagGeneralString = 27
-pkg encoding/asn1, const TagGeneralString ideal-int
-pkg encoding/asn1, const TagGeneralizedTime = 24
-pkg encoding/asn1, const TagGeneralizedTime ideal-int
-pkg encoding/asn1, const TagIA5String = 22
-pkg encoding/asn1, const TagIA5String ideal-int
-pkg encoding/asn1, const TagInteger = 2
-pkg encoding/asn1, const TagInteger ideal-int
-pkg encoding/asn1, const TagOID = 6
-pkg encoding/asn1, const TagOID ideal-int
-pkg encoding/asn1, const TagOctetString = 4
-pkg encoding/asn1, const TagOctetString ideal-int
-pkg encoding/asn1, const TagPrintableString = 19
-pkg encoding/asn1, const TagPrintableString ideal-int
-pkg encoding/asn1, const TagSequence = 16
-pkg encoding/asn1, const TagSequence ideal-int
-pkg encoding/asn1, const TagSet = 17
-pkg encoding/asn1, const TagSet ideal-int
-pkg encoding/asn1, const TagT61String = 20
-pkg encoding/asn1, const TagT61String ideal-int
-pkg encoding/asn1, const TagUTCTime = 23
-pkg encoding/asn1, const TagUTCTime ideal-int
-pkg encoding/asn1, const TagUTF8String = 12
-pkg encoding/asn1, const TagUTF8String ideal-int
-pkg go/build, const IgnoreVendor = 8
-pkg go/build, const IgnoreVendor ImportMode
-pkg go/build, type Package struct, InvalidGoFiles []string
-pkg go/constant, func ToComplex(Value) Value
-pkg go/constant, func ToFloat(Value) Value
-pkg go/constant, func ToInt(Value) Value
-pkg go/constant, type Value interface, ExactString() string
-pkg go/types, method (*Package) SetName(string)
-pkg go/types, type ImportMode int
-pkg go/types, type ImporterFrom interface { Import, ImportFrom }
-pkg go/types, type ImporterFrom interface, Import(string) (*Package, error)
-pkg go/types, type ImporterFrom interface, ImportFrom(string, string, ImportMode) (*Package, error)
-pkg html/template, func IsTrue(interface{}) (bool, bool)
-pkg html/template, method (*Template) DefinedTemplates() string
-pkg image, func NewNYCbCrA(Rectangle, YCbCrSubsampleRatio) *NYCbCrA
-pkg image, method (*NYCbCrA) AOffset(int, int) int
-pkg image, method (*NYCbCrA) At(int, int) color.Color
-pkg image, method (*NYCbCrA) Bounds() Rectangle
-pkg image, method (*NYCbCrA) COffset(int, int) int
-pkg image, method (*NYCbCrA) ColorModel() color.Model
-pkg image, method (*NYCbCrA) NYCbCrAAt(int, int) color.NYCbCrA
-pkg image, method (*NYCbCrA) Opaque() bool
-pkg image, method (*NYCbCrA) SubImage(Rectangle) Image
-pkg image, method (*NYCbCrA) YCbCrAt(int, int) color.YCbCr
-pkg image, method (*NYCbCrA) YOffset(int, int) int
-pkg image, type NYCbCrA struct
-pkg image, type NYCbCrA struct, A []uint8
-pkg image, type NYCbCrA struct, AStride int
-pkg image, type NYCbCrA struct, embedded YCbCr
-pkg image/color, method (NYCbCrA) RGBA() (uint32, uint32, uint32, uint32)
-pkg image/color, type NYCbCrA struct
-pkg image/color, type NYCbCrA struct, A uint8
-pkg image/color, type NYCbCrA struct, embedded YCbCr
-pkg image/color, var NYCbCrAModel Model
-pkg math/big, method (*Float) MarshalText() ([]uint8, error)
-pkg math/big, method (*Float) UnmarshalText([]uint8) error
-pkg math/big, method (*Int) Append([]uint8, int) []uint8
-pkg math/big, method (*Int) Text(int) string
-pkg math/rand, func Read([]uint8) (int, error)
-pkg math/rand, method (*Rand) Read([]uint8) (int, error)
-pkg net, type DNSError struct, IsTemporary bool
-pkg net, type Dialer struct, Cancel <-chan struct
-pkg net/http, const MethodConnect = "CONNECT"
-pkg net/http, const MethodConnect ideal-string
-pkg net/http, const MethodDelete = "DELETE"
-pkg net/http, const MethodDelete ideal-string
-pkg net/http, const MethodGet = "GET"
-pkg net/http, const MethodGet ideal-string
-pkg net/http, const MethodHead = "HEAD"
-pkg net/http, const MethodHead ideal-string
-pkg net/http, const MethodOptions = "OPTIONS"
-pkg net/http, const MethodOptions ideal-string
-pkg net/http, const MethodPatch = "PATCH"
-pkg net/http, const MethodPatch ideal-string
-pkg net/http, const MethodPost = "POST"
-pkg net/http, const MethodPost ideal-string
-pkg net/http, const MethodPut = "PUT"
-pkg net/http, const MethodPut ideal-string
-pkg net/http, const MethodTrace = "TRACE"
-pkg net/http, const MethodTrace ideal-string
-pkg net/http, const StatusNetworkAuthenticationRequired = 511
-pkg net/http, const StatusNetworkAuthenticationRequired ideal-int
-pkg net/http, const StatusPreconditionRequired = 428
-pkg net/http, const StatusPreconditionRequired ideal-int
-pkg net/http, const StatusRequestHeaderFieldsTooLarge = 431
-pkg net/http, const StatusRequestHeaderFieldsTooLarge ideal-int
-pkg net/http, const StatusTooManyRequests = 429
-pkg net/http, const StatusTooManyRequests ideal-int
-pkg net/http, const StatusUnavailableForLegalReasons = 451
-pkg net/http, const StatusUnavailableForLegalReasons ideal-int
-pkg net/http, type Transport struct, ExpectContinueTimeout time.Duration
-pkg net/http, type Transport struct, TLSNextProto map[string]func(string, *tls.Conn) RoundTripper
-pkg net/http, var ErrSkipAltProtocol error
-pkg net/http/httptest, method (*ResponseRecorder) WriteString(string) (int, error)
-pkg net/http/httputil, type BufferPool interface { Get, Put }
-pkg net/http/httputil, type BufferPool interface, Get() []uint8
-pkg net/http/httputil, type BufferPool interface, Put([]uint8)
-pkg net/http/httputil, type ReverseProxy struct, BufferPool BufferPool
-pkg net/url, method (*Error) Temporary() bool
-pkg net/url, method (*Error) Timeout() bool
-pkg net/url, method (InvalidHostError) Error() string
-pkg net/url, type InvalidHostError string
-pkg os/exec, type ExitError struct, Stderr []uint8
-pkg regexp, method (*Regexp) Copy() *Regexp
-pkg runtime/debug, func SetTraceback(string)
-pkg strconv, func AppendQuoteRuneToGraphic([]uint8, int32) []uint8
-pkg strconv, func AppendQuoteToGraphic([]uint8, string) []uint8
-pkg strconv, func IsGraphic(int32) bool
-pkg strconv, func QuoteRuneToGraphic(int32) string
-pkg strconv, func QuoteToGraphic(string) string
-pkg text/template, func IsTrue(interface{}) (bool, bool)
-pkg text/template, method (ExecError) Error() string
-pkg text/template, type ExecError struct
-pkg text/template, type ExecError struct, Err error
-pkg text/template, type ExecError struct, Name string
--- a/api/go1.7.txt
+++ b/api/go1.7.txt
@@ -1,285 +0,0 @@
-pkg bytes, func ContainsAny([]uint8, string) bool
-pkg bytes, func ContainsRune([]uint8, int32) bool
-pkg bytes, method (*Reader) Reset([]uint8)
-pkg compress/flate, const HuffmanOnly = -2
-pkg compress/flate, const HuffmanOnly ideal-int
-pkg context, func Background() Context
-pkg context, func TODO() Context
-pkg context, func WithCancel(Context) (Context, CancelFunc)
-pkg context, func WithDeadline(Context, time.Time) (Context, CancelFunc)
-pkg context, func WithTimeout(Context, time.Duration) (Context, CancelFunc)
-pkg context, func WithValue(Context, interface{}, interface{}) Context
-pkg context, type CancelFunc func()
-pkg context, type Context interface { Deadline, Done, Err, Value }
-pkg context, type Context interface, Deadline() (time.Time, bool)
-pkg context, type Context interface, Done() <-chan struct
-pkg context, type Context interface, Err() error
-pkg context, type Context interface, Value(interface{}) interface{}
-pkg context, var Canceled error
-pkg context, var DeadlineExceeded error
-pkg crypto/tls, const RenegotiateFreelyAsClient = 2
-pkg crypto/tls, const RenegotiateFreelyAsClient RenegotiationSupport
-pkg crypto/tls, const RenegotiateNever = 0
-pkg crypto/tls, const RenegotiateNever RenegotiationSupport
-pkg crypto/tls, const RenegotiateOnceAsClient = 1
-pkg crypto/tls, const RenegotiateOnceAsClient RenegotiationSupport
-pkg crypto/tls, type Config struct, DynamicRecordSizingDisabled bool
-pkg crypto/tls, type Config struct, Renegotiation RenegotiationSupport
-pkg crypto/tls, type RenegotiationSupport int
-pkg crypto/x509, func SystemCertPool() (*CertPool, error)
-pkg crypto/x509, type SystemRootsError struct, Err error
-pkg debug/dwarf, method (*Data) Ranges(*Entry) ([][2]uint64, error)
-pkg debug/dwarf, method (*Reader) SeekPC(uint64) (*Entry, error)
-pkg debug/elf, const R_390_12 = 2
-pkg debug/elf, const R_390_12 R_390
-pkg debug/elf, const R_390_16 = 3
-pkg debug/elf, const R_390_16 R_390
-pkg debug/elf, const R_390_20 = 57
-pkg debug/elf, const R_390_20 R_390
-pkg debug/elf, const R_390_32 = 4
-pkg debug/elf, const R_390_32 R_390
-pkg debug/elf, const R_390_64 = 22
-pkg debug/elf, const R_390_64 R_390
-pkg debug/elf, const R_390_8 = 1
-pkg debug/elf, const R_390_8 R_390
-pkg debug/elf, const R_390_COPY = 9
-pkg debug/elf, const R_390_COPY R_390
-pkg debug/elf, const R_390_GLOB_DAT = 10
-pkg debug/elf, const R_390_GLOB_DAT R_390
-pkg debug/elf, const R_390_GOT12 = 6
-pkg debug/elf, const R_390_GOT12 R_390
-pkg debug/elf, const R_390_GOT16 = 15
-pkg debug/elf, const R_390_GOT16 R_390
-pkg debug/elf, const R_390_GOT20 = 58
-pkg debug/elf, const R_390_GOT20 R_390
-pkg debug/elf, const R_390_GOT32 = 7
-pkg debug/elf, const R_390_GOT32 R_390
-pkg debug/elf, const R_390_GOT64 = 24
-pkg debug/elf, const R_390_GOT64 R_390
-pkg debug/elf, const R_390_GOTENT = 26
-pkg debug/elf, const R_390_GOTENT R_390
-pkg debug/elf, const R_390_GOTOFF = 13
-pkg debug/elf, const R_390_GOTOFF R_390
-pkg debug/elf, const R_390_GOTOFF16 = 27
-pkg debug/elf, const R_390_GOTOFF16 R_390
-pkg debug/elf, const R_390_GOTOFF64 = 28
-pkg debug/elf, const R_390_GOTOFF64 R_390
-pkg debug/elf, const R_390_GOTPC = 14
-pkg debug/elf, const R_390_GOTPC R_390
-pkg debug/elf, const R_390_GOTPCDBL = 21
-pkg debug/elf, const R_390_GOTPCDBL R_390
-pkg debug/elf, const R_390_GOTPLT12 = 29
-pkg debug/elf, const R_390_GOTPLT12 R_390
-pkg debug/elf, const R_390_GOTPLT16 = 30
-pkg debug/elf, const R_390_GOTPLT16 R_390
-pkg debug/elf, const R_390_GOTPLT20 = 59
-pkg debug/elf, const R_390_GOTPLT20 R_390
-pkg debug/elf, const R_390_GOTPLT32 = 31
-pkg debug/elf, const R_390_GOTPLT32 R_390
-pkg debug/elf, const R_390_GOTPLT64 = 32
-pkg debug/elf, const R_390_GOTPLT64 R_390
-pkg debug/elf, const R_390_GOTPLTENT = 33
-pkg debug/elf, const R_390_GOTPLTENT R_390
-pkg debug/elf, const R_390_GOTPLTOFF16 = 34
-pkg debug/elf, const R_390_GOTPLTOFF16 R_390
-pkg debug/elf, const R_390_GOTPLTOFF32 = 35
-pkg debug/elf, const R_390_GOTPLTOFF32 R_390
-pkg debug/elf, const R_390_GOTPLTOFF64 = 36
-pkg debug/elf, const R_390_GOTPLTOFF64 R_390
-pkg debug/elf, const R_390_JMP_SLOT = 11
-pkg debug/elf, const R_390_JMP_SLOT R_390
-pkg debug/elf, const R_390_NONE = 0
-pkg debug/elf, const R_390_NONE R_390
-pkg debug/elf, const R_390_PC16 = 16
-pkg debug/elf, const R_390_PC16 R_390
-pkg debug/elf, const R_390_PC16DBL = 17
-pkg debug/elf, const R_390_PC16DBL R_390
-pkg debug/elf, const R_390_PC32 = 5
-pkg debug/elf, const R_390_PC32 R_390
-pkg debug/elf, const R_390_PC32DBL = 19
-pkg debug/elf, const R_390_PC32DBL R_390
-pkg debug/elf, const R_390_PC64 = 23
-pkg debug/elf, const R_390_PC64 R_390
-pkg debug/elf, const R_390_PLT16DBL = 18
-pkg debug/elf, const R_390_PLT16DBL R_390
-pkg debug/elf, const R_390_PLT32 = 8
-pkg debug/elf, const R_390_PLT32 R_390
-pkg debug/elf, const R_390_PLT32DBL = 20
-pkg debug/elf, const R_390_PLT32DBL R_390
-pkg debug/elf, const R_390_PLT64 = 25
-pkg debug/elf, const R_390_PLT64 R_390
-pkg debug/elf, const R_390_RELATIVE = 12
-pkg debug/elf, const R_390_RELATIVE R_390
-pkg debug/elf, const R_390_TLS_DTPMOD = 54
-pkg debug/elf, const R_390_TLS_DTPMOD R_390
-pkg debug/elf, const R_390_TLS_DTPOFF = 55
-pkg debug/elf, const R_390_TLS_DTPOFF R_390
-pkg debug/elf, const R_390_TLS_GD32 = 40
-pkg debug/elf, const R_390_TLS_GD32 R_390
-pkg debug/elf, const R_390_TLS_GD64 = 41
-pkg debug/elf, const R_390_TLS_GD64 R_390
-pkg debug/elf, const R_390_TLS_GDCALL = 38
-pkg debug/elf, const R_390_TLS_GDCALL R_390
-pkg debug/elf, const R_390_TLS_GOTIE12 = 42
-pkg debug/elf, const R_390_TLS_GOTIE12 R_390
-pkg debug/elf, const R_390_TLS_GOTIE20 = 60
-pkg debug/elf, const R_390_TLS_GOTIE20 R_390
-pkg debug/elf, const R_390_TLS_GOTIE32 = 43
-pkg debug/elf, const R_390_TLS_GOTIE32 R_390
-pkg debug/elf, const R_390_TLS_GOTIE64 = 44
-pkg debug/elf, const R_390_TLS_GOTIE64 R_390
-pkg debug/elf, const R_390_TLS_IE32 = 47
-pkg debug/elf, const R_390_TLS_IE32 R_390
-pkg debug/elf, const R_390_TLS_IE64 = 48
-pkg debug/elf, const R_390_TLS_IE64 R_390
-pkg debug/elf, const R_390_TLS_IEENT = 49
-pkg debug/elf, const R_390_TLS_IEENT R_390
-pkg debug/elf, const R_390_TLS_LDCALL = 39
-pkg debug/elf, const R_390_TLS_LDCALL R_390
-pkg debug/elf, const R_390_TLS_LDM32 = 45
-pkg debug/elf, const R_390_TLS_LDM32 R_390
-pkg debug/elf, const R_390_TLS_LDM64 = 46
-pkg debug/elf, const R_390_TLS_LDM64 R_390
-pkg debug/elf, const R_390_TLS_LDO32 = 52
-pkg debug/elf, const R_390_TLS_LDO32 R_390
-pkg debug/elf, const R_390_TLS_LDO64 = 53
-pkg debug/elf, const R_390_TLS_LDO64 R_390
-pkg debug/elf, const R_390_TLS_LE32 = 50
-pkg debug/elf, const R_390_TLS_LE32 R_390
-pkg debug/elf, const R_390_TLS_LE64 = 51
-pkg debug/elf, const R_390_TLS_LE64 R_390
-pkg debug/elf, const R_390_TLS_LOAD = 37
-pkg debug/elf, const R_390_TLS_LOAD R_390
-pkg debug/elf, const R_390_TLS_TPOFF = 56
-pkg debug/elf, const R_390_TLS_TPOFF R_390
-pkg debug/elf, method (R_390) GoString() string
-pkg debug/elf, method (R_390) String() string
-pkg debug/elf, type R_390 int
-pkg encoding/json, method (*Encoder) SetEscapeHTML(bool)
-pkg encoding/json, method (*Encoder) SetIndent(string, string)
-pkg go/build, type Package struct, BinaryOnly bool
-pkg go/build, type Package struct, CgoFFLAGS []string
-pkg go/build, type Package struct, FFiles []string
-pkg go/doc, type Example struct, Unordered bool
-pkg io, const SeekCurrent = 1
-pkg io, const SeekCurrent ideal-int
-pkg io, const SeekEnd = 2
-pkg io, const SeekEnd ideal-int
-pkg io, const SeekStart = 0
-pkg io, const SeekStart ideal-int
-pkg math/big, method (*Float) GobDecode([]uint8) error
-pkg math/big, method (*Float) GobEncode() ([]uint8, error)
-pkg net, method (*Dialer) DialContext(context.Context, string, string) (Conn, error)
-pkg net/http, const StatusAlreadyReported = 208
-pkg net/http, const StatusAlreadyReported ideal-int
-pkg net/http, const StatusFailedDependency = 424
-pkg net/http, const StatusFailedDependency ideal-int
-pkg net/http, const StatusIMUsed = 226
-pkg net/http, const StatusIMUsed ideal-int
-pkg net/http, const StatusInsufficientStorage = 507
-pkg net/http, const StatusInsufficientStorage ideal-int
-pkg net/http, const StatusLocked = 423
-pkg net/http, const StatusLocked ideal-int
-pkg net/http, const StatusLoopDetected = 508
-pkg net/http, const StatusLoopDetected ideal-int
-pkg net/http, const StatusMultiStatus = 207
-pkg net/http, const StatusMultiStatus ideal-int
-pkg net/http, const StatusNotExtended = 510
-pkg net/http, const StatusNotExtended ideal-int
-pkg net/http, const StatusPermanentRedirect = 308
-pkg net/http, const StatusPermanentRedirect ideal-int
-pkg net/http, const StatusProcessing = 102
-pkg net/http, const StatusProcessing ideal-int
-pkg net/http, const StatusUnprocessableEntity = 422
-pkg net/http, const StatusUnprocessableEntity ideal-int
-pkg net/http, const StatusUpgradeRequired = 426
-pkg net/http, const StatusUpgradeRequired ideal-int
-pkg net/http, const StatusVariantAlsoNegotiates = 506
-pkg net/http, const StatusVariantAlsoNegotiates ideal-int
-pkg net/http, method (*Request) Context() context.Context
-pkg net/http, method (*Request) WithContext(context.Context) *Request
-pkg net/http, type Request struct, Response *Response
-pkg net/http, type Response struct, Uncompressed bool
-pkg net/http, type Transport struct, DialContext func(context.Context, string, string) (net.Conn, error)
-pkg net/http, type Transport struct, IdleConnTimeout time.Duration
-pkg net/http, type Transport struct, MaxIdleConns int
-pkg net/http, type Transport struct, MaxResponseHeaderBytes int64
-pkg net/http, var ErrUseLastResponse error
-pkg net/http, var LocalAddrContextKey *contextKey
-pkg net/http, var ServerContextKey *contextKey
-pkg net/http/cgi, type Handler struct, Stderr io.Writer
-pkg net/http/httptest, func NewRequest(string, string, io.Reader) *http.Request
-pkg net/http/httptest, method (*ResponseRecorder) Result() *http.Response
-pkg net/http/httptrace, func ContextClientTrace(context.Context) *ClientTrace
-pkg net/http/httptrace, func WithClientTrace(context.Context, *ClientTrace) context.Context
-pkg net/http/httptrace, type ClientTrace struct
-pkg net/http/httptrace, type ClientTrace struct, ConnectDone func(string, string, error)
-pkg net/http/httptrace, type ClientTrace struct, ConnectStart func(string, string)
-pkg net/http/httptrace, type ClientTrace struct, DNSDone func(DNSDoneInfo)
-pkg net/http/httptrace, type ClientTrace struct, DNSStart func(DNSStartInfo)
-pkg net/http/httptrace, type ClientTrace struct, GetConn func(string)
-pkg net/http/httptrace, type ClientTrace struct, Got100Continue func()
-pkg net/http/httptrace, type ClientTrace struct, GotConn func(GotConnInfo)
-pkg net/http/httptrace, type ClientTrace struct, GotFirstResponseByte func()
-pkg net/http/httptrace, type ClientTrace struct, PutIdleConn func(error)
-pkg net/http/httptrace, type ClientTrace struct, Wait100Continue func()
-pkg net/http/httptrace, type ClientTrace struct, WroteHeaders func()
-pkg net/http/httptrace, type ClientTrace struct, WroteRequest func(WroteRequestInfo)
-pkg net/http/httptrace, type DNSDoneInfo struct
-pkg net/http/httptrace, type DNSDoneInfo struct, Addrs []net.IPAddr
-pkg net/http/httptrace, type DNSDoneInfo struct, Coalesced bool
-pkg net/http/httptrace, type DNSDoneInfo struct, Err error
-pkg net/http/httptrace, type DNSStartInfo struct
-pkg net/http/httptrace, type DNSStartInfo struct, Host string
-pkg net/http/httptrace, type GotConnInfo struct
-pkg net/http/httptrace, type GotConnInfo struct, Conn net.Conn
-pkg net/http/httptrace, type GotConnInfo struct, IdleTime time.Duration
-pkg net/http/httptrace, type GotConnInfo struct, Reused bool
-pkg net/http/httptrace, type GotConnInfo struct, WasIdle bool
-pkg net/http/httptrace, type WroteRequestInfo struct
-pkg net/http/httptrace, type WroteRequestInfo struct, Err error
-pkg net/url, type URL struct, ForceQuery bool
-pkg os/exec, func CommandContext(context.Context, string, ...string) *Cmd
-pkg os/user, func LookupGroup(string) (*Group, error)
-pkg os/user, func LookupGroupId(string) (*Group, error)
-pkg os/user, method (*User) GroupIds() ([]string, error)
-pkg os/user, method (UnknownGroupError) Error() string
-pkg os/user, method (UnknownGroupIdError) Error() string
-pkg os/user, type Group struct
-pkg os/user, type Group struct, Gid string
-pkg os/user, type Group struct, Name string
-pkg os/user, type UnknownGroupError string
-pkg os/user, type UnknownGroupIdError string
-pkg reflect, func StructOf([]StructField) Type
-pkg reflect, method (StructTag) Lookup(string) (string, bool)
-pkg runtime, func CallersFrames([]uintptr) *Frames
-pkg runtime, func KeepAlive(interface{})
-pkg runtime, func SetCgoTraceback(int, unsafe.Pointer, unsafe.Pointer, unsafe.Pointer)
-pkg runtime, method (*Frames) Next() (Frame, bool)
-pkg runtime, type Frame struct
-pkg runtime, type Frame struct, Entry uintptr
-pkg runtime, type Frame struct, File string
-pkg runtime, type Frame struct, Func *Func
-pkg runtime, type Frame struct, Function string
-pkg runtime, type Frame struct, Line int
-pkg runtime, type Frame struct, PC uintptr
-pkg runtime, type Frames struct
-pkg strings, method (*Reader) Reset(string)
-pkg syscall (linux-386), type SysProcAttr struct, Unshareflags uintptr
-pkg syscall (linux-386-cgo), type SysProcAttr struct, Unshareflags uintptr
-pkg syscall (linux-amd64), type SysProcAttr struct, Unshareflags uintptr
-pkg syscall (linux-amd64-cgo), type SysProcAttr struct, Unshareflags uintptr
-pkg syscall (linux-arm), type SysProcAttr struct, Unshareflags uintptr
-pkg syscall (linux-arm-cgo), type SysProcAttr struct, Unshareflags uintptr
-pkg testing, method (*B) Run(string, func(*B)) bool
-pkg testing, method (*T) Run(string, func(*T)) bool
-pkg testing, type InternalExample struct, Unordered bool
-pkg unicode, const Version = "9.0.0"
-pkg unicode, var Adlam *RangeTable
-pkg unicode, var Bhaiksuki *RangeTable
-pkg unicode, var Marchen *RangeTable
-pkg unicode, var Newa *RangeTable
-pkg unicode, var Osage *RangeTable
-pkg unicode, var Prepended_Concatenation_Mark *RangeTable
-pkg unicode, var Sentence_Terminal *RangeTable
-pkg unicode, var Tangut *RangeTable
--- a/api/go1.8.txt
+++ b/api/go1.8.txt
@@ -1,261 +0,0 @@
-pkg compress/gzip, const HuffmanOnly = -2
-pkg compress/gzip, const HuffmanOnly ideal-int
-pkg compress/zlib, const HuffmanOnly = -2
-pkg compress/zlib, const HuffmanOnly ideal-int
-pkg crypto/tls, const ECDSAWithP256AndSHA256 = 1027
-pkg crypto/tls, const ECDSAWithP256AndSHA256 SignatureScheme
-pkg crypto/tls, const ECDSAWithP384AndSHA384 = 1283
-pkg crypto/tls, const ECDSAWithP384AndSHA384 SignatureScheme
-pkg crypto/tls, const ECDSAWithP521AndSHA512 = 1539
-pkg crypto/tls, const ECDSAWithP521AndSHA512 SignatureScheme
-pkg crypto/tls, const PKCS1WithSHA1 = 513
-pkg crypto/tls, const PKCS1WithSHA1 SignatureScheme
-pkg crypto/tls, const PKCS1WithSHA256 = 1025
-pkg crypto/tls, const PKCS1WithSHA256 SignatureScheme
-pkg crypto/tls, const PKCS1WithSHA384 = 1281
-pkg crypto/tls, const PKCS1WithSHA384 SignatureScheme
-pkg crypto/tls, const PKCS1WithSHA512 = 1537
-pkg crypto/tls, const PKCS1WithSHA512 SignatureScheme
-pkg crypto/tls, const PSSWithSHA256 = 2052
-pkg crypto/tls, const PSSWithSHA256 SignatureScheme
-pkg crypto/tls, const PSSWithSHA384 = 2053
-pkg crypto/tls, const PSSWithSHA384 SignatureScheme
-pkg crypto/tls, const PSSWithSHA512 = 2054
-pkg crypto/tls, const PSSWithSHA512 SignatureScheme
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = 49187
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 uint16
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 = 52393
-pkg crypto/tls, const TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 uint16
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = 49191
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 uint16
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305 = 52392
-pkg crypto/tls, const TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305 uint16
-pkg crypto/tls, const TLS_RSA_WITH_AES_128_CBC_SHA256 = 60
-pkg crypto/tls, const TLS_RSA_WITH_AES_128_CBC_SHA256 uint16
-pkg crypto/tls, const X25519 = 29
-pkg crypto/tls, const X25519 CurveID
-pkg crypto/tls, method (*Config) Clone() *Config
-pkg crypto/tls, method (*Conn) CloseWrite() error
-pkg crypto/tls, type CertificateRequestInfo struct
-pkg crypto/tls, type CertificateRequestInfo struct, AcceptableCAs [][]uint8
-pkg crypto/tls, type CertificateRequestInfo struct, SignatureSchemes []SignatureScheme
-pkg crypto/tls, type ClientHelloInfo struct, Conn net.Conn
-pkg crypto/tls, type ClientHelloInfo struct, SignatureSchemes []SignatureScheme
-pkg crypto/tls, type ClientHelloInfo struct, SupportedProtos []string
-pkg crypto/tls, type ClientHelloInfo struct, SupportedVersions []uint16
-pkg crypto/tls, type Config struct, GetClientCertificate func(*CertificateRequestInfo) (*Certificate, error)
-pkg crypto/tls, type Config struct, GetConfigForClient func(*ClientHelloInfo) (*Config, error)
-pkg crypto/tls, type Config struct, KeyLogWriter io.Writer
-pkg crypto/tls, type Config struct, VerifyPeerCertificate func([][]uint8, [][]*x509.Certificate) error
-pkg crypto/tls, type SignatureScheme uint16
-pkg crypto/x509, const NameMismatch = 5
-pkg crypto/x509, const NameMismatch InvalidReason
-pkg crypto/x509, const SHA256WithRSAPSS = 13
-pkg crypto/x509, const SHA256WithRSAPSS SignatureAlgorithm
-pkg crypto/x509, const SHA384WithRSAPSS = 14
-pkg crypto/x509, const SHA384WithRSAPSS SignatureAlgorithm
-pkg crypto/x509, const SHA512WithRSAPSS = 15
-pkg crypto/x509, const SHA512WithRSAPSS SignatureAlgorithm
-pkg crypto/x509, type UnknownAuthorityError struct, Cert *Certificate
-pkg database/sql, const LevelDefault = 0
-pkg database/sql, const LevelDefault IsolationLevel
-pkg database/sql, const LevelLinearizable = 7
-pkg database/sql, const LevelLinearizable IsolationLevel
-pkg database/sql, const LevelReadCommitted = 2
-pkg database/sql, const LevelReadCommitted IsolationLevel
-pkg database/sql, const LevelReadUncommitted = 1
-pkg database/sql, const LevelReadUncommitted IsolationLevel
-pkg database/sql, const LevelRepeatableRead = 4
-pkg database/sql, const LevelRepeatableRead IsolationLevel
-pkg database/sql, const LevelSerializable = 6
-pkg database/sql, const LevelSerializable IsolationLevel
-pkg database/sql, const LevelSnapshot = 5
-pkg database/sql, const LevelSnapshot IsolationLevel
-pkg database/sql, const LevelWriteCommitted = 3
-pkg database/sql, const LevelWriteCommitted IsolationLevel
-pkg database/sql/driver, type ConnBeginTx interface { BeginTx }
-pkg database/sql/driver, type ConnBeginTx interface, BeginTx(context.Context, TxOptions) (Tx, error)
-pkg database/sql/driver, type ConnPrepareContext interface { PrepareContext }
-pkg database/sql/driver, type ConnPrepareContext interface, PrepareContext(context.Context, string) (Stmt, error)
-pkg database/sql/driver, type ExecerContext interface { ExecContext }
-pkg database/sql/driver, type ExecerContext interface, ExecContext(context.Context, string, []NamedValue) (Result, error)
-pkg database/sql/driver, type IsolationLevel int
-pkg database/sql/driver, type NamedValue struct
-pkg database/sql/driver, type NamedValue struct, Name string
-pkg database/sql/driver, type NamedValue struct, Ordinal int
-pkg database/sql/driver, type NamedValue struct, Value Value
-pkg database/sql/driver, type Pinger interface { Ping }
-pkg database/sql/driver, type Pinger interface, Ping(context.Context) error
-pkg database/sql/driver, type QueryerContext interface { QueryContext }
-pkg database/sql/driver, type QueryerContext interface, QueryContext(context.Context, string, []NamedValue) (Rows, error)
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface { Close, ColumnTypeDatabaseTypeName, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, Close() error
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, ColumnTypeDatabaseTypeName(int) string
-pkg database/sql/driver, type RowsColumnTypeDatabaseTypeName interface, Next([]Value) error
-pkg database/sql/driver, type RowsColumnTypeLength interface { Close, ColumnTypeLength, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypeLength interface, Close() error
-pkg database/sql/driver, type RowsColumnTypeLength interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypeLength interface, ColumnTypeLength(int) (int64, bool)
-pkg database/sql/driver, type RowsColumnTypeLength interface, Next([]Value) error
-pkg database/sql/driver, type RowsColumnTypeNullable interface { Close, ColumnTypeNullable, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypeNullable interface, Close() error
-pkg database/sql/driver, type RowsColumnTypeNullable interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypeNullable interface, ColumnTypeNullable(int) (bool, bool)
-pkg database/sql/driver, type RowsColumnTypeNullable interface, Next([]Value) error
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface { Close, ColumnTypePrecisionScale, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, Close() error
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, ColumnTypePrecisionScale(int) (int64, int64, bool)
-pkg database/sql/driver, type RowsColumnTypePrecisionScale interface, Next([]Value) error
-pkg database/sql/driver, type RowsColumnTypeScanType interface { Close, ColumnTypeScanType, Columns, Next }
-pkg database/sql/driver, type RowsColumnTypeScanType interface, Close() error
-pkg database/sql/driver, type RowsColumnTypeScanType interface, Columns() []string
-pkg database/sql/driver, type RowsColumnTypeScanType interface, ColumnTypeScanType(int) reflect.Type
-pkg database/sql/driver, type RowsColumnTypeScanType interface, Next([]Value) error
-pkg database/sql/driver, type RowsNextResultSet interface { Close, Columns, HasNextResultSet, Next, NextResultSet }
-pkg database/sql/driver, type RowsNextResultSet interface, Close() error
-pkg database/sql/driver, type RowsNextResultSet interface, Columns() []string
-pkg database/sql/driver, type RowsNextResultSet interface, HasNextResultSet() bool
-pkg database/sql/driver, type RowsNextResultSet interface, NextResultSet() error
-pkg database/sql/driver, type RowsNextResultSet interface, Next([]Value) error
-pkg database/sql/driver, type StmtExecContext interface { ExecContext }
-pkg database/sql/driver, type StmtExecContext interface, ExecContext(context.Context, []NamedValue) (Result, error)
-pkg database/sql/driver, type StmtQueryContext interface { QueryContext }
-pkg database/sql/driver, type StmtQueryContext interface, QueryContext(context.Context, []NamedValue) (Rows, error)
-pkg database/sql/driver, type TxOptions struct
-pkg database/sql/driver, type TxOptions struct, Isolation IsolationLevel
-pkg database/sql/driver, type TxOptions struct, ReadOnly bool
-pkg database/sql, func Named(string, interface{}) NamedArg
-pkg database/sql, method (*ColumnType) DatabaseTypeName() string
-pkg database/sql, method (*ColumnType) DecimalSize() (int64, int64, bool)
-pkg database/sql, method (*ColumnType) Length() (int64, bool)
-pkg database/sql, method (*ColumnType) Name() string
-pkg database/sql, method (*ColumnType) Nullable() (bool, bool)
-pkg database/sql, method (*ColumnType) ScanType() reflect.Type
-pkg database/sql, method (*DB) BeginTx(context.Context, *TxOptions) (*Tx, error)
-pkg database/sql, method (*DB) ExecContext(context.Context, string, ...interface{}) (Result, error)
-pkg database/sql, method (*DB) PingContext(context.Context) error
-pkg database/sql, method (*DB) PrepareContext(context.Context, string) (*Stmt, error)
-pkg database/sql, method (*DB) QueryContext(context.Context, string, ...interface{}) (*Rows, error)
-pkg database/sql, method (*DB) QueryRowContext(context.Context, string, ...interface{}) *Row
-pkg database/sql, method (*Rows) ColumnTypes() ([]*ColumnType, error)
-pkg database/sql, method (*Rows) NextResultSet() bool
-pkg database/sql, method (*Stmt) ExecContext(context.Context, ...interface{}) (Result, error)
-pkg database/sql, method (*Stmt) QueryContext(context.Context, ...interface{}) (*Rows, error)
-pkg database/sql, method (*Stmt) QueryRowContext(context.Context, ...interface{}) *Row
-pkg database/sql, method (*Tx) ExecContext(context.Context, string, ...interface{}) (Result, error)
-pkg database/sql, method (*Tx) PrepareContext(context.Context, string) (*Stmt, error)
-pkg database/sql, method (*Tx) QueryContext(context.Context, string, ...interface{}) (*Rows, error)
-pkg database/sql, method (*Tx) QueryRowContext(context.Context, string, ...interface{}) *Row
-pkg database/sql, method (*Tx) StmtContext(context.Context, *Stmt) *Stmt
-pkg database/sql, type ColumnType struct
-pkg database/sql, type IsolationLevel int
-pkg database/sql, type NamedArg struct
-pkg database/sql, type NamedArg struct, Name string
-pkg database/sql, type NamedArg struct, Value interface{}
-pkg database/sql, type TxOptions struct
-pkg database/sql, type TxOptions struct, Isolation IsolationLevel
-pkg database/sql, type TxOptions struct, ReadOnly bool
-pkg debug/pe, method (*COFFSymbol) FullName(StringTable) (string, error)
-pkg debug/pe, method (StringTable) String(uint32) (string, error)
-pkg debug/pe, type File struct, COFFSymbols []COFFSymbol
-pkg debug/pe, type File struct, StringTable StringTable
-pkg debug/pe, type Reloc struct
-pkg debug/pe, type Reloc struct, SymbolTableIndex uint32
-pkg debug/pe, type Reloc struct, Type uint16
-pkg debug/pe, type Reloc struct, VirtualAddress uint32
-pkg debug/pe, type Section struct, Relocs []Reloc
-pkg debug/pe, type StringTable []uint8
-pkg encoding/base64, method (Encoding) Strict() *Encoding
-pkg encoding/json, method (RawMessage) MarshalJSON() ([]uint8, error)
-pkg encoding/json, type UnmarshalTypeError struct, Field string
-pkg encoding/json, type UnmarshalTypeError struct, Struct string
-pkg expvar, func Handler() http.Handler
-pkg expvar, method (*Float) Value() float64
-pkg expvar, method (Func) Value() interface{}
-pkg expvar, method (*Int) Value() int64
-pkg expvar, method (*String) Value() string
-pkg go/doc, func IsPredeclared(string) bool
-pkg go/types, func Default(Type) Type
-pkg go/types, func IdenticalIgnoreTags(Type, Type) bool
-pkg math/big, method (*Float) Scan(fmt.ScanState, int32) error
-pkg math/big, method (*Int) Sqrt(*Int) *Int
-pkg math/rand, func Uint64() uint64
-pkg math/rand, method (*Rand) Uint64() uint64
-pkg math/rand, type Source64 interface, Int63() int64
-pkg math/rand, type Source64 interface { Int63, Seed, Uint64 }
-pkg math/rand, type Source64 interface, Seed(int64)
-pkg math/rand, type Source64 interface, Uint64() uint64
-pkg net/http, const TrailerPrefix ideal-string
-pkg net/http, const TrailerPrefix = "Trailer:"
-pkg net/http/httptrace, type ClientTrace struct, TLSHandshakeDone func(tls.ConnectionState, error)
-pkg net/http/httptrace, type ClientTrace struct, TLSHandshakeStart func()
-pkg net/http/httputil, type ReverseProxy struct, ModifyResponse func(*http.Response) error
-pkg net/http, method (*Server) Close() error
-pkg net/http, method (*Server) Shutdown(context.Context) error
-pkg net/http, type Pusher interface { Push }
-pkg net/http, type Pusher interface, Push(string, *PushOptions) error
-pkg net/http, type PushOptions struct
-pkg net/http, type PushOptions struct, Header Header
-pkg net/http, type PushOptions struct, Method string
-pkg net/http, type Request struct, GetBody func() (io.ReadCloser, error)
-pkg net/http, type Server struct, IdleTimeout time.Duration
-pkg net/http, type Server struct, ReadHeaderTimeout time.Duration
-pkg net/http, type Transport struct, ProxyConnectHeader Header
-pkg net/http, var ErrAbortHandler error
-pkg net/http, var ErrServerClosed error
-pkg net/http, var NoBody noBody
-pkg net/mail, func ParseDate(string) (time.Time, error)
-pkg net, method (*Buffers) Read([]uint8) (int, error)
-pkg net, method (*Buffers) WriteTo(io.Writer) (int64, error)
-pkg net, method (*Resolver) LookupAddr(context.Context, string) ([]string, error)
-pkg net, method (*Resolver) LookupCNAME(context.Context, string) (string, error)
-pkg net, method (*Resolver) LookupHost(context.Context, string) ([]string, error)
-pkg net, method (*Resolver) LookupIPAddr(context.Context, string) ([]IPAddr, error)
-pkg net, method (*Resolver) LookupMX(context.Context, string) ([]*MX, error)
-pkg net, method (*Resolver) LookupNS(context.Context, string) ([]*NS, error)
-pkg net, method (*Resolver) LookupPort(context.Context, string, string) (int, error)
-pkg net, method (*Resolver) LookupSRV(context.Context, string, string, string) (string, []*SRV, error)
-pkg net, method (*Resolver) LookupTXT(context.Context, string) ([]string, error)
-pkg net, method (*UnixListener) SetUnlinkOnClose(bool)
-pkg net, type Buffers [][]uint8
-pkg net, type Dialer struct, Resolver *Resolver
-pkg net, type Resolver struct
-pkg net, type Resolver struct, PreferGo bool
-pkg net/url, func PathEscape(string) string
-pkg net/url, func PathUnescape(string) (string, error)
-pkg net/url, method (*URL) Hostname() string
-pkg net/url, method (*URL) MarshalBinary() ([]uint8, error)
-pkg net/url, method (*URL) Port() string
-pkg net/url, method (*URL) UnmarshalBinary([]uint8) error
-pkg net, var DefaultResolver *Resolver
-pkg os, func Executable() (string, error)
-pkg os, var ErrClosed error
-pkg plugin, func Open(string) (*Plugin, error)
-pkg plugin, method (*Plugin) Lookup(string) (Symbol, error)
-pkg plugin, type Plugin struct
-pkg plugin, type Symbol interface {}
-pkg reflect, func Swapper(interface{}) func(int, int)
-pkg runtime, func MutexProfile([]BlockProfileRecord) (int, bool)
-pkg runtime, func SetMutexProfileFraction(int) int
-pkg runtime, type MemStats struct, NumForcedGC uint32
-pkg sort, func Slice(interface{}, func(int, int) bool)
-pkg sort, func SliceIsSorted(interface{}, func(int, int) bool) bool
-pkg sort, func SliceStable(interface{}, func(int, int) bool)
-pkg syscall (linux-arm-cgo), func TimevalToNsec(Timeval) int64
-pkg syscall (linux-arm), func TimevalToNsec(Timeval) int64
-pkg syscall (openbsd-386), const SYS_KILL = 122
-pkg syscall (openbsd-386-cgo), const SYS_KILL = 122
-pkg syscall (openbsd-amd64), const SYS_KILL = 122
-pkg syscall (openbsd-amd64-cgo), const SYS_KILL = 122
-pkg syscall (windows-386), const ERROR_DIR_NOT_EMPTY = 145
-pkg syscall (windows-386), const ERROR_DIR_NOT_EMPTY Errno
-pkg syscall (windows-amd64), const ERROR_DIR_NOT_EMPTY = 145
-pkg syscall (windows-amd64), const ERROR_DIR_NOT_EMPTY Errno
-pkg testing, func CoverMode() string
-pkg testing, func MainStart(testDeps, []InternalTest, []InternalBenchmark, []InternalExample) *M
-pkg testing, method (*B) Name() string
-pkg testing, method (*T) Name() string
-pkg testing, type TB interface, Name() string
-pkg time, func Until(Time) Duration
--- a/api/go1.9.txt
+++ b/api/go1.9.txt
@@ -1,169 +0,0 @@
-pkg crypto, const BLAKE2b_256 = 17
-pkg crypto, const BLAKE2b_256 Hash
-pkg crypto, const BLAKE2b_384 = 18
-pkg crypto, const BLAKE2b_384 Hash
-pkg crypto, const BLAKE2b_512 = 19
-pkg crypto, const BLAKE2b_512 Hash
-pkg crypto, const BLAKE2s_256 = 16
-pkg crypto, const BLAKE2s_256 Hash
-pkg crypto/x509, type Certificate struct, ExcludedDNSDomains []string
-pkg database/sql, method (*Conn) BeginTx(context.Context, *TxOptions) (*Tx, error)
-pkg database/sql, method (*Conn) Close() error
-pkg database/sql, method (*Conn) ExecContext(context.Context, string, ...interface{}) (Result, error)
-pkg database/sql, method (*Conn) PingContext(context.Context) error
-pkg database/sql, method (*Conn) PrepareContext(context.Context, string) (*Stmt, error)
-pkg database/sql, method (*Conn) QueryContext(context.Context, string, ...interface{}) (*Rows, error)
-pkg database/sql, method (*Conn) QueryRowContext(context.Context, string, ...interface{}) *Row
-pkg database/sql, method (*DB) Conn(context.Context) (*Conn, error)
-pkg database/sql, type Conn struct
-pkg database/sql, type Out struct
-pkg database/sql, type Out struct, Dest interface{}
-pkg database/sql, type Out struct, In bool
-pkg database/sql, var ErrConnDone error
-pkg database/sql/driver, type NamedValueChecker interface { CheckNamedValue }
-pkg database/sql/driver, type NamedValueChecker interface, CheckNamedValue(*NamedValue) error
-pkg database/sql/driver, var ErrRemoveArgument error
-pkg encoding/asn1, const TagNull = 5
-pkg encoding/asn1, const TagNull ideal-int
-pkg encoding/asn1, var NullBytes []uint8
-pkg encoding/asn1, var NullRawValue RawValue
-pkg encoding/base32, const NoPadding = -1
-pkg encoding/base32, const NoPadding int32
-pkg encoding/base32, const StdPadding = 61
-pkg encoding/base32, const StdPadding int32
-pkg encoding/base32, method (Encoding) WithPadding(int32) *Encoding
-pkg encoding/csv, type Reader struct, ReuseRecord bool
-pkg encoding/json, func Valid([]uint8) bool
-pkg go/ast, type TypeSpec struct, Assign token.Pos
-pkg go/types, func SizesFor(string, string) Sizes
-pkg go/types, method (*TypeName) IsAlias() bool
-pkg hash/fnv, func New128() hash.Hash
-pkg hash/fnv, func New128a() hash.Hash
-pkg html/template, const ErrPredefinedEscaper = 11
-pkg html/template, const ErrPredefinedEscaper ErrorCode
-pkg image/png, type Encoder struct, BufferPool EncoderBufferPool
-pkg image/png, type EncoderBuffer struct
-pkg image/png, type EncoderBufferPool interface { Get, Put }
-pkg image/png, type EncoderBufferPool interface, Get() *EncoderBuffer
-pkg image/png, type EncoderBufferPool interface, Put(*EncoderBuffer)
-pkg math/big, method (*Int) IsInt64() bool
-pkg math/big, method (*Int) IsUint64() bool
-pkg math/big, type Word uint
-pkg math/bits, const UintSize = 64
-pkg math/bits, const UintSize ideal-int
-pkg math/bits, func LeadingZeros(uint) int
-pkg math/bits, func LeadingZeros16(uint16) int
-pkg math/bits, func LeadingZeros32(uint32) int
-pkg math/bits, func LeadingZeros64(uint64) int
-pkg math/bits, func LeadingZeros8(uint8) int
-pkg math/bits, func Len(uint) int
-pkg math/bits, func Len16(uint16) int
-pkg math/bits, func Len32(uint32) int
-pkg math/bits, func Len64(uint64) int
-pkg math/bits, func Len8(uint8) int
-pkg math/bits, func OnesCount(uint) int
-pkg math/bits, func OnesCount16(uint16) int
-pkg math/bits, func OnesCount32(uint32) int
-pkg math/bits, func OnesCount64(uint64) int
-pkg math/bits, func OnesCount8(uint8) int
-pkg math/bits, func Reverse(uint) uint
-pkg math/bits, func Reverse16(uint16) uint16
-pkg math/bits, func Reverse32(uint32) uint32
-pkg math/bits, func Reverse64(uint64) uint64
-pkg math/bits, func Reverse8(uint8) uint8
-pkg math/bits, func ReverseBytes(uint) uint
-pkg math/bits, func ReverseBytes16(uint16) uint16
-pkg math/bits, func ReverseBytes32(uint32) uint32
-pkg math/bits, func ReverseBytes64(uint64) uint64
-pkg math/bits, func RotateLeft(uint, int) uint
-pkg math/bits, func RotateLeft16(uint16, int) uint16
-pkg math/bits, func RotateLeft32(uint32, int) uint32
-pkg math/bits, func RotateLeft64(uint64, int) uint64
-pkg math/bits, func RotateLeft8(uint8, int) uint8
-pkg math/bits, func TrailingZeros(uint) int
-pkg math/bits, func TrailingZeros16(uint16) int
-pkg math/bits, func TrailingZeros32(uint32) int
-pkg math/bits, func TrailingZeros64(uint64) int
-pkg math/bits, func TrailingZeros8(uint8) int
-pkg mime, var ErrInvalidMediaParameter error
-pkg mime/multipart, type FileHeader struct, Size int64
-pkg mime/multipart, var ErrMessageTooLarge error
-pkg net, method (*IPConn) SyscallConn() (syscall.RawConn, error)
-pkg net, method (*TCPConn) SyscallConn() (syscall.RawConn, error)
-pkg net, method (*UDPConn) SyscallConn() (syscall.RawConn, error)
-pkg net, method (*UnixConn) SyscallConn() (syscall.RawConn, error)
-pkg net, type Resolver struct, Dial func(context.Context, string, string) (Conn, error)
-pkg net, type Resolver struct, StrictErrors bool
-pkg net/http, func ServeTLS(net.Listener, Handler, string, string) error
-pkg net/http, method (*Server) RegisterOnShutdown(func())
-pkg net/http, method (*Server) ServeTLS(net.Listener, string, string) error
-pkg net/http/fcgi, func ProcessEnv(*http.Request) map[string]string
-pkg net/http/httptest, method (*Server) Certificate() *x509.Certificate
-pkg net/http/httptest, method (*Server) Client() *http.Client
-pkg reflect, func MakeMapWithSize(Type, int) Value
-pkg runtime/pprof, func Do(context.Context, LabelSet, func(context.Context))
-pkg runtime/pprof, func ForLabels(context.Context, func(string, string) bool)
-pkg runtime/pprof, func Label(context.Context, string) (string, bool)
-pkg runtime/pprof, func Labels(...string) LabelSet
-pkg runtime/pprof, func SetGoroutineLabels(context.Context)
-pkg runtime/pprof, func WithLabels(context.Context, LabelSet) context.Context
-pkg runtime/pprof, type LabelSet struct
-pkg sync, method (*Map) Delete(interface{})
-pkg sync, method (*Map) Load(interface{}) (interface{}, bool)
-pkg sync, method (*Map) LoadOrStore(interface{}, interface{}) (interface{}, bool)
-pkg sync, method (*Map) Range(func(interface{}, interface{}) bool)
-pkg sync, method (*Map) Store(interface{}, interface{})
-pkg sync, type Map struct
-pkg syscall (darwin-386-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (darwin-386), type Credential struct, NoSetGroups bool
-pkg syscall (darwin-amd64-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (darwin-amd64), type Credential struct, NoSetGroups bool
-pkg syscall (freebsd-386-cgo), func Pipe2([]int, int) error
-pkg syscall (freebsd-386-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (freebsd-386), func Pipe2([]int, int) error
-pkg syscall (freebsd-386), type Credential struct, NoSetGroups bool
-pkg syscall (freebsd-amd64-cgo), func Pipe2([]int, int) error
-pkg syscall (freebsd-amd64-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (freebsd-amd64), func Pipe2([]int, int) error
-pkg syscall (freebsd-amd64), type Credential struct, NoSetGroups bool
-pkg syscall (freebsd-arm-cgo), func Pipe2([]int, int) error
-pkg syscall (freebsd-arm-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (freebsd-arm), func Pipe2([]int, int) error
-pkg syscall (freebsd-arm), type Credential struct, NoSetGroups bool
-pkg syscall (linux-386-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (linux-386-cgo), type SysProcAttr struct, AmbientCaps []uintptr
-pkg syscall (linux-386), type Credential struct, NoSetGroups bool
-pkg syscall (linux-386), type SysProcAttr struct, AmbientCaps []uintptr
-pkg syscall (linux-amd64-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (linux-amd64-cgo), type SysProcAttr struct, AmbientCaps []uintptr
-pkg syscall (linux-amd64), type Credential struct, NoSetGroups bool
-pkg syscall (linux-amd64), type SysProcAttr struct, AmbientCaps []uintptr
-pkg syscall (linux-arm-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (linux-arm-cgo), type SysProcAttr struct, AmbientCaps []uintptr
-pkg syscall (linux-arm), type Credential struct, NoSetGroups bool
-pkg syscall (linux-arm), type SysProcAttr struct, AmbientCaps []uintptr
-pkg syscall (netbsd-386-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (netbsd-386), type Credential struct, NoSetGroups bool
-pkg syscall (netbsd-amd64-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (netbsd-amd64), type Credential struct, NoSetGroups bool
-pkg syscall (netbsd-arm-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (netbsd-arm), type Credential struct, NoSetGroups bool
-pkg syscall (openbsd-386-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (openbsd-386), type Credential struct, NoSetGroups bool
-pkg syscall (openbsd-amd64-cgo), type Credential struct, NoSetGroups bool
-pkg syscall (openbsd-amd64), type Credential struct, NoSetGroups bool
-pkg syscall (windows-386), const WSAECONNABORTED = 10053
-pkg syscall (windows-386), const WSAECONNABORTED Errno
-pkg syscall (windows-amd64), const WSAECONNABORTED = 10053
-pkg syscall (windows-amd64), const WSAECONNABORTED Errno
-pkg syscall, type Conn interface { SyscallConn }
-pkg syscall, type Conn interface, SyscallConn() (RawConn, error)
-pkg syscall, type RawConn interface { Control, Read, Write }
-pkg syscall, type RawConn interface, Control(func(uintptr)) error
-pkg syscall, type RawConn interface, Read(func(uintptr) bool) error
-pkg syscall, type RawConn interface, Write(func(uintptr) bool) error
-pkg testing, method (*B) Helper()
-pkg testing, method (*T) Helper()
-pkg testing, type TB interface, Helper()
-pkg time, method (Duration) Round(Duration) Duration
-pkg time, method (Duration) Truncate(Duration) Duration
--- a/api/next.txt
+++ b/api/next.txt
@@ -0,0 +1,141 @@
+pkg debug/goobj, const SBSS = 21
+pkg debug/goobj, const SBSS SymKind
+pkg debug/goobj, const SCONST = 31
+pkg debug/goobj, const SCONST SymKind
+pkg debug/goobj, const SDATA = 19
+pkg debug/goobj, const SDATA SymKind
+pkg debug/goobj, const SDYNIMPORT = 32
+pkg debug/goobj, const SDYNIMPORT SymKind
+pkg debug/goobj, const SELFROSECT = 12
+pkg debug/goobj, const SELFROSECT SymKind
+pkg debug/goobj, const SELFRXSECT = 2
+pkg debug/goobj, const SELFRXSECT SymKind
+pkg debug/goobj, const SELFSECT = 14
+pkg debug/goobj, const SELFSECT SymKind
+pkg debug/goobj, const SFILE = 29
+pkg debug/goobj, const SFILE SymKind
+pkg debug/goobj, const SFILEPATH = 30
+pkg debug/goobj, const SFILEPATH SymKind
+pkg debug/goobj, const SFUNCTAB = 8
+pkg debug/goobj, const SFUNCTAB SymKind
+pkg debug/goobj, const SGOFUNC = 6
+pkg debug/goobj, const SGOFUNC SymKind
+pkg debug/goobj, const SGOSTRING = 5
+pkg debug/goobj, const SGOSTRING SymKind
+pkg debug/goobj, const SHOSTOBJ = 33
+pkg debug/goobj, const SHOSTOBJ SymKind
+pkg debug/goobj, const SINITARR = 18
+pkg debug/goobj, const SINITARR SymKind
+pkg debug/goobj, const SMACHO = 15
+pkg debug/goobj, const SMACHO SymKind
+pkg debug/goobj, const SMACHOGOT = 16
+pkg debug/goobj, const SMACHOGOT SymKind
+pkg debug/goobj, const SMACHOINDIRECTGOT = 28
+pkg debug/goobj, const SMACHOINDIRECTGOT SymKind
+pkg debug/goobj, const SMACHOINDIRECTPLT = 27
+pkg debug/goobj, const SMACHOINDIRECTPLT SymKind
+pkg debug/goobj, const SMACHOPLT = 13
+pkg debug/goobj, const SMACHOPLT SymKind
+pkg debug/goobj, const SMACHOSYMSTR = 25
+pkg debug/goobj, const SMACHOSYMSTR SymKind
+pkg debug/goobj, const SMACHOSYMTAB = 26
+pkg debug/goobj, const SMACHOSYMTAB SymKind
+pkg debug/goobj, const SNOPTRBSS = 22
+pkg debug/goobj, const SNOPTRBSS SymKind
+pkg debug/goobj, const SNOPTRDATA = 17
+pkg debug/goobj, const SNOPTRDATA SymKind
+pkg debug/goobj, const SPCLNTAB = 11
+pkg debug/goobj, const SPCLNTAB SymKind
+pkg debug/goobj, const SRODATA = 7
+pkg debug/goobj, const SRODATA SymKind
+pkg debug/goobj, const SSTRING = 4
+pkg debug/goobj, const SSTRING SymKind
+pkg debug/goobj, const SSYMTAB = 10
+pkg debug/goobj, const SSYMTAB SymKind
+pkg debug/goobj, const STEXT = 1
+pkg debug/goobj, const STEXT SymKind
+pkg debug/goobj, const STLSBSS = 23
+pkg debug/goobj, const STLSBSS SymKind
+pkg debug/goobj, const STYPE = 3
+pkg debug/goobj, const STYPE SymKind
+pkg debug/goobj, const STYPELINK = 9
+pkg debug/goobj, const STYPELINK SymKind
+pkg debug/goobj, const SWINDOWS = 20
+pkg debug/goobj, const SWINDOWS SymKind
+pkg debug/goobj, const SXREF = 24
+pkg debug/goobj, const SXREF SymKind
+pkg debug/goobj, func Parse(io.ReadSeeker, string) (*Package, error)
+pkg debug/goobj, method (Sym) String() string
+pkg debug/goobj, method (SymID) String() string
+pkg debug/goobj, method (SymKind) String() string
+pkg debug/goobj, type Data struct
+pkg debug/goobj, type Data struct, Offset int64
+pkg debug/goobj, type Data struct, Size int64
+pkg debug/goobj, type Func struct
+pkg debug/goobj, type Func struct, Args int
+pkg debug/goobj, type Func struct, File []string
+pkg debug/goobj, type Func struct, Frame int
+pkg debug/goobj, type Func struct, FuncData []FuncData
+pkg debug/goobj, type Func struct, Leaf bool
+pkg debug/goobj, type Func struct, NoSplit bool
+pkg debug/goobj, type Func struct, PCData []Data
+pkg debug/goobj, type Func struct, PCFile Data
+pkg debug/goobj, type Func struct, PCLine Data
+pkg debug/goobj, type Func struct, PCSP Data
+pkg debug/goobj, type Func struct, Var []Var
+pkg debug/goobj, type FuncData struct
+pkg debug/goobj, type FuncData struct, Offset int64
+pkg debug/goobj, type FuncData struct, Sym SymID
+pkg debug/goobj, type Package struct
+pkg debug/goobj, type Package struct, ImportPath string
+pkg debug/goobj, type Package struct, Imports []string
+pkg debug/goobj, type Package struct, MaxVersion int
+pkg debug/goobj, type Package struct, Syms []*Sym
+pkg debug/goobj, type Reloc struct
+pkg debug/goobj, type Reloc struct, Add int
+pkg debug/goobj, type Reloc struct, Offset int
+pkg debug/goobj, type Reloc struct, Size int
+pkg debug/goobj, type Reloc struct, Sym SymID
+pkg debug/goobj, type Reloc struct, Type int
+pkg debug/goobj, type Sym struct
+pkg debug/goobj, type Sym struct, Data Data
+pkg debug/goobj, type Sym struct, DupOK bool
+pkg debug/goobj, type Sym struct, Func *Func
+pkg debug/goobj, type Sym struct, Kind SymKind
+pkg debug/goobj, type Sym struct, Reloc []Reloc
+pkg debug/goobj, type Sym struct, Size int
+pkg debug/goobj, type Sym struct, Type SymID
+pkg debug/goobj, type Sym struct, embedded SymID
+pkg debug/goobj, type SymID struct
+pkg debug/goobj, type SymID struct, Name string
+pkg debug/goobj, type SymID struct, Version int
+pkg debug/goobj, type SymKind int
+pkg debug/goobj, type Var struct
+pkg debug/goobj, type Var struct, Kind int
+pkg debug/goobj, type Var struct, Name string
+pkg debug/goobj, type Var struct, Offset int
+pkg debug/goobj, type Var struct, Type SymID
+pkg unicode, const Version = "7.0.0"
+pkg unicode, var Bassa_Vah *RangeTable
+pkg unicode, var Caucasian_Albanian *RangeTable
+pkg unicode, var Duployan *RangeTable
+pkg unicode, var Elbasan *RangeTable
+pkg unicode, var Grantha *RangeTable
+pkg unicode, var Khojki *RangeTable
+pkg unicode, var Khudawadi *RangeTable
+pkg unicode, var Linear_A *RangeTable
+pkg unicode, var Mahajani *RangeTable
+pkg unicode, var Manichaean *RangeTable
+pkg unicode, var Mende_Kikakui *RangeTable
+pkg unicode, var Modi *RangeTable
+pkg unicode, var Mro *RangeTable
+pkg unicode, var Nabataean *RangeTable
+pkg unicode, var Old_North_Arabian *RangeTable
+pkg unicode, var Old_Permic *RangeTable
+pkg unicode, var Pahawh_Hmong *RangeTable
+pkg unicode, var Palmyrene *RangeTable
+pkg unicode, var Pau_Cin_Hau *RangeTable
+pkg unicode, var Psalter_Pahlavi *RangeTable
+pkg unicode, var Siddham *RangeTable
+pkg unicode, var Tirhuta *RangeTable
+pkg unicode, var Warang_Citi *RangeTable
--- a/doc/articles/go_command.html
+++ b/doc/articles/go_command.html
@@ -97,14 +97,13 @@ a tool like the go command to look at an unfamiliar import path and
 deduce where to obtain the source code.</p>

 <p>Second, the place to store sources in the local file system is derived
-in a known way from the import path, specifically
-<code>$GOPATH/src/&lt;import-path&gt;</code>.
-If unset, <code>$GOPATH</code> defaults to a subdirectory
-named <code>go</code> in the user's home directory.
+in a known way from the import path.  Specifically, the first choice
+is <code>$GOPATH/src/&lt;import-path&gt;</code>.  If <code>$GOPATH</code> is
+unset, the go command will fall back to storing source code alongside the
+standard Go packages, in <code>$GOROOT/src/&lt;import-path&gt;</code>.
 If <code>$GOPATH</code> is set to a list of paths, the go command tries
 <code>&lt;dir&gt;/src/&lt;import-path&gt;</code> for each of the directories in
-that list.
-</p>
+that list.</p>

 <p>Each of those trees contains, by convention, a top-level directory named
 "<code>bin</code>", for holding compiled executables, and a top-level directory
@@ -138,26 +137,41 @@ to the use of a specific tool chain.</p>

 <h2>Getting started with the go command</h2>

-<p>Finally, a quick tour of how to use the go command.
-As mentioned above, the default <code>$GOPATH</code> on Unix is <code>$HOME/go</code>.
-We'll store our programs there.
-To use a different location, you can set <code>$GOPATH</code>;
-see <a href="/doc/code.html">How to Write Go Code</a> for details.
+<p>Finally, a quick tour of how to use the go command, to supplement
+the information in <a href="/doc/code.html">How to Write Go Code</a>,
+which you might want to read first.  Assuming you want
+to keep your source code separate from the Go distribution source
+tree, the first step is to set <code>$GOPATH</code>, the one piece of global
+configuration that the go command needs.  The <code>$GOPATH</code> can be a
+list of directories, but by far the most common usage should be to set it to a
+single directory.  In particular, you do not need a separate entry in
+<code>$GOPATH</code> for each of your projects.  One <code>$GOPATH</code> can
+support many projects.</p>

-<p>We first add some source code.  Suppose we want to use
+<p>Here’s an example.  Let’s say we decide to keep our Go code in the directory
+<code>$HOME/mygo</code>.  We need to create that directory and set
+<code>$GOPATH</code> accordingly.</p>
+
+<pre>
+$ mkdir $HOME/mygo
+$ export GOPATH=$HOME/mygo
+$
+</pre>
+
+<p>Into this directory, we now add some source code.  Suppose we want to use
 the indexing library from the codesearch project along with a left-leaning
 red-black tree.  We can install both with the "<code>go get</code>"
 subcommand:</p>

 <pre>
-$ go get github.com/google/codesearch/index
+$ go get code.google.com/p/codesearch/index
 $ go get github.com/petar/GoLLRB/llrb
 $
 </pre>

-<p>Both of these projects are now downloaded and installed into <code>$HOME/go</code>,
-which contains the two directories
-<code>src/github.com/google/codesearch/index/</code> and
+<p>Both of these projects are now downloaded and installed into our
+<code>$GOPATH</code> directory. The one tree now contains the two directories
+<code>src/code.google.com/p/codesearch/index/</code> and
 <code>src/github.com/petar/GoLLRB/llrb/</code>, along with the compiled
 packages (in <code>pkg/</code>) for those libraries and their dependencies.</p>

@@ -170,14 +184,13 @@ the pattern "<code>./...</code>" means start in the current directory
 ("<code>...</code>"):</p>

 <pre>
-$ cd $HOME/go/src
 $ go list ./...
-github.com/google/codesearch/cmd/cgrep
-github.com/google/codesearch/cmd/cindex
-github.com/google/codesearch/cmd/csearch
-github.com/google/codesearch/index
-github.com/google/codesearch/regexp
-github.com/google/codesearch/sparse
+code.google.com/p/codesearch/cmd/cgrep
+code.google.com/p/codesearch/cmd/cindex
+code.google.com/p/codesearch/cmd/csearch
+code.google.com/p/codesearch/index
+code.google.com/p/codesearch/regexp
+code.google.com/p/codesearch/sparse
 github.com/petar/GoLLRB/example
 github.com/petar/GoLLRB/llrb
 $
@@ -187,12 +200,12 @@ $

 <pre>
 $ go test ./...
-?   	github.com/google/codesearch/cmd/cgrep	[no test files]
-?   	github.com/google/codesearch/cmd/cindex	[no test files]
-?   	github.com/google/codesearch/cmd/csearch	[no test files]
-ok  	github.com/google/codesearch/index	0.203s
-ok  	github.com/google/codesearch/regexp	0.017s
-?   	github.com/google/codesearch/sparse	[no test files]
+?       code.google.com/p/codesearch/cmd/cgrep   [no test files]
+?       code.google.com/p/codesearch/cmd/cindex  [no test files]
+?       code.google.com/p/codesearch/cmd/csearch [no test files]
+ok      code.google.com/p/codesearch/index       0.239s
+ok      code.google.com/p/codesearch/regexp      0.021s
+?       code.google.com/p/codesearch/sparse      [no test files]
 ?       github.com/petar/GoLLRB/example          [no test files]
 ok      github.com/petar/GoLLRB/llrb             0.231s
 $
@@ -202,18 +215,18 @@ $
 current directory:</p>

 <pre>
-$ cd github.com/google/codesearch/regexp
+$ cd $GOPATH/src/code.google.com/p/codesearch/regexp
 $ go list
-github.com/google/codesearch/regexp
+code.google.com/p/codesearch/regexp
 $ go test -v
-=== RUN   TestNstateEnc
--- PASS: TestNstateEnc (0.00s)
-=== RUN   TestMatch
--- PASS: TestMatch (0.00s)
-=== RUN   TestGrep
--- PASS: TestGrep (0.00s)
+=== RUN TestNstateEnc
+--- PASS: TestNstateEnc (0.00 seconds)
+=== RUN TestMatch
+--- PASS: TestMatch (0.01 seconds)
+=== RUN TestGrep
+--- PASS: TestGrep (0.00 seconds)
 PASS
-ok  	github.com/google/codesearch/regexp	0.018s
+ok      code.google.com/p/codesearch/regexp     0.021s
 $ go install
 $
 </pre>
@@ -231,18 +244,17 @@ pick such a long name, but that ability would require additional configuration
 and complexity in the tool. Typing an extra directory name or two is a small
 price to pay for the increased simplicity and power.</p>

+<p>As the example shows, it’s fine to work with packages from many different
+projects at once within a single <code>$GOPATH</code> root directory.</p>
+
 <h2>Limitations</h2>

 <p>As mentioned above, the go command is not a general-purpose build
-tool.
-In particular, it does not have any facility for generating Go
-source files <em>during</em> a build, although it does provide
-<a href="/cmd/go/#hdr-Generate_Go_files_by_processing_source"><code>go</code>
-<code>generate</code></a>,
-which can automate the creation of Go files <em>before</em> the build.
-For more advanced build setups, you may need to write a
+tool. In particular, it does not have any facility for generating Go
+source files during a build.  Instead, if you want to use a tool like
+yacc or the protocol buffer compiler, you will need to write a
 makefile (or a configuration file for the build tool of your choice)
-to run whatever tool creates the Go files and then check those generated source files
+to generate the Go files and then check those generated source files
 into your repository. This is more work for you, the package author,
 but it is significantly less work for your users, who can use
 "<code>go get</code>" without needing to obtain and build
--- a/doc/articles/wiki/final-test.patch
+++ b/doc/articles/wiki/final-test.patch
@@ -1,36 +0,0 @@
-*** final.go	2015-06-14 23:59:22.000000000 +0200
--- final-test.go	2015-06-15 00:15:41.000000000 +0200
-***************
-*** 7,12 ****
--- 7,14 ----
-  import (
-  	"html/template"
-  	"io/ioutil"
-+ 	"log"
-+ 	"net"
-  	"net/http"
-  	"regexp"
-  )
-***************
-*** 85,89 ****
-  	http.HandleFunc("/edit/", makeHandler(editHandler))
-  	http.HandleFunc("/save/", makeHandler(saveHandler))
-  
-! 	http.ListenAndServe(":8080", nil)
-  }
--- 87,101 ----
-  	http.HandleFunc("/edit/", makeHandler(editHandler))
-  	http.HandleFunc("/save/", makeHandler(saveHandler))
-  
-! 	l, err := net.Listen("tcp", "127.0.0.1:0")
-! 	if err != nil {
-! 		log.Fatal(err)
-! 	}
-! 	err = ioutil.WriteFile("final-test-port.txt", []byte(l.Addr().String()), 0644)
-! 	if err != nil {
-! 		log.Fatal(err)
-! 	}
-! 	s := &http.Server{}
-! 	s.Serve(l)
-! 	return
-  }
--- a/doc/articles/wiki/final.go
+++ b/doc/articles/wiki/final.go
@@ -5,12 +5,19 @@
 package main

 import (
+	"flag"
 	"html/template"
 	"io/ioutil"
+	"log"
+	"net"
 	"net/http"
 	"regexp"
 )

+var (
+	addr = flag.Bool("addr", false, "find open address and print to final-port.txt")
+)
+
 type Page struct {
 	Title string
 	Body  []byte
@@ -81,9 +88,24 @@ func makeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.Handl
 }

 func main() {
+	flag.Parse()
 	http.HandleFunc("/view/", makeHandler(viewHandler))
 	http.HandleFunc("/edit/", makeHandler(editHandler))
 	http.HandleFunc("/save/", makeHandler(saveHandler))

+	if *addr {
+		l, err := net.Listen("tcp", "127.0.0.1:0")
+		if err != nil {
+			log.Fatal(err)
+		}
+		err = ioutil.WriteFile("final-port.txt", []byte(l.Addr().String()), 0644)
+		if err != nil {
+			log.Fatal(err)
+		}
+		s := &http.Server{}
+		s.Serve(l)
+		return
+	}
+
 	http.ListenAndServe(":8080", nil)
 }
--- a/doc/articles/wiki/test.bash
+++ b/doc/articles/wiki/test.bash
@@ -4,37 +4,29 @@
 # license that can be found in the LICENSE file.

 set -e
-
-if ! which patch > /dev/null; then
-	echo "Skipping test; patch command not found."
-	exit 0
-fi
-
 wiki_pid=
 cleanup() {
 	kill $wiki_pid
-	rm -f test_*.out Test.txt final-test.go final-test.bin final-test-port.txt a.out get.bin
+	rm -f test_*.out Test.txt final.bin final-port.txt a.out get.bin
 }
 trap cleanup 0 INT

-rm -f get.bin final-test.bin a.out
+rm -f get.bin final.bin a.out

 # If called with -all, check that all code snippets compile.
-if [ "$1" = "-all" ]; then
+if [ "$1" == "-all" ]; then
 	for fn in *.go; do
 		go build -o a.out $fn
 	done
 fi

 go build -o get.bin get.go
-cp final.go final-test.go
-patch final-test.go final-test.patch > /dev/null
-go build -o final-test.bin final-test.go
-./final-test.bin &
+go build -o final.bin final.go
+(./final.bin --addr) &
 wiki_pid=$!

 l=0
-while [ ! -f ./final-test-port.txt ]
+while [ ! -f ./final-port.txt ]
 do
 	l=$(($l+1))
 	if [ "$l" -gt 5 ]
@@ -46,7 +38,7 @@ do
 	sleep 1
 done

-addr=$(cat final-test-port.txt)
+addr=$(cat final-port.txt)
 ./get.bin http://$addr/edit/Test > test_edit.out
 diff -u test_edit.out test_edit.good
 ./get.bin -post=body=some%20content http://$addr/save/Test > test_save.out
--- a/doc/asm.html
+++ b/doc/asm.html
@@ -6,16 +6,16 @@
 <h2 id="introduction">A Quick Guide to Go's Assembler</h2>

 <p>
-This document is a quick outline of the unusual form of assembly language used by the <code>gc</code> Go compiler.
+This document is a quick outline of the unusual form of assembly language used by the <code>gc</code>
+suite of Go compilers (<code>6g</code>, <code>8g</code>, etc.).
 The document is not comprehensive.
 </p>

 <p>
-The assembler is based on the input style of the Plan 9 assemblers, which is documented in detail
-<a href="https://9p.io/sys/doc/asm.html">elsewhere</a>.
+The assembler is based on the input to the Plan 9 assemblers, which is documented in detail
+<a href="http://plan9.bell-labs.com/sys/doc/asm.html">on the Plan 9 site</a>.
 If you plan to write assembly language, you should read that document although much of it is Plan 9-specific.
-The current document provides a summary of the syntax and the differences with
-what is explained in that document, and
+This document provides a summary of the syntax and
 describes the peculiarities that apply when writing assembly code to interact with Go.
 </p>

@@ -23,14 +23,12 @@ describes the peculiarities that apply when writing assembly code to interact wi
 The most important thing to know about Go's assembler is that it is not a direct representation of the underlying machine.
 Some of the details map precisely to the machine, but some do not.
 This is because the compiler suite (see
-<a href="https://9p.io/sys/doc/compiler.html">this description</a>)
+<a href="http://plan9.bell-labs.com/sys/doc/compiler.html">this description</a>)
 needs no assembler pass in the usual pipeline.
-Instead, the compiler operates on a kind of semi-abstract instruction set,
-and instruction selection occurs partly after code generation.
-The assembler works on the semi-abstract form, so
-when you see an instruction like <code>MOV</code>
-what the tool chain actually generates for that operation might
-not be a move instruction at all, perhaps a clear or load.
+Instead, the compiler emits a kind of incompletely defined instruction set, in binary form, which the linker
+then completes.
+In particular, the linker does instruction selection, so when you see an instruction like <code>MOV</code>
+what the linker actually generates for that operation might not be a move instruction at all, perhaps a clear or load.
 Or it might correspond exactly to the machine instruction with that name.
 In general, machine-specific operations tend to appear as themselves, while more general concepts like
 memory move and subroutine call and return are more abstract.
@@ -38,15 +36,13 @@ The details vary with architecture, and we apologize for the imprecision; the si
 </p>

 <p>
-The assembler program is a way to parse a description of that
-semi-abstract instruction set and turn it into instructions to be
-input to the linker.
+The assembler program is a way to generate that intermediate, incompletely defined instruction sequence
+as input for the linker.
 If you want to see what the instructions look like in assembly for a given architecture, say amd64, there
 are many examples in the sources of the standard library, in packages such as
 <a href="/pkg/runtime/"><code>runtime</code></a> and
 <a href="/pkg/math/big/"><code>math/big</code></a>.
-You can also examine what the compiler emits as assembly code
-(the actual output may differ from what you see here):
+You can also examine what the compiler emits as assembly code:
 </p>

 <pre>
@@ -56,7 +52,7 @@ package main
 func main() {
 	println(3)
 }
-$ GOOS=linux GOARCH=amd64 go tool compile -S x.go        # or: go build -gcflags -S x.go
+$ go tool 6g -S x.go        # or: go build -gcflags -S x.go

 --- prog list "main" ---
 0000 (x.go:3) TEXT    main+0(SB),$8-0
@@ -110,73 +106,20 @@ codeblk [0x2000,0x1d059) at offset 0x1000

 -->

-<h3 id="constants">Constants</h3>
-
-<p>
-Although the assembler takes its guidance from the Plan 9 assemblers,
-it is a distinct program, so there are some differences.
-One is in constant evaluation.
-Constant expressions in the assembler are parsed using Go's operator
-precedence, not the C-like precedence of the original.
-Thus <code>3&amp;1<<2</code> is 4, not 0—it parses as <code>(3&amp;1)<<2</code>
-not <code>3&amp;(1<<2)</code>.
-Also, constants are always evaluated as 64-bit unsigned integers.
-Thus <code>-2</code> is not the integer value minus two,
-but the unsigned 64-bit integer with the same bit pattern.
-The distinction rarely matters but
-to avoid ambiguity, division or right shift where the right operand's
-high bit is set is rejected.
-</p>
-
 <h3 id="symbols">Symbols</h3>

 <p>
-Some symbols, such as <code>R1</code> or <code>LR</code>,
-are predefined and refer to registers.
-The exact set depends on the architecture.
-</p>
-
-<p>
-There are four predeclared symbols that refer to pseudo-registers.
-These are not real registers, but rather virtual registers maintained by
-the tool chain, such as a frame pointer.
-The set of pseudo-registers is the same for all architectures:
-</p>
-
-<ul>
-
-<li>
-<code>FP</code>: Frame pointer: arguments and locals.
-</li>
-
-<li>
-<code>PC</code>: Program counter:
-jumps and branches.
-</li>
-
-<li>
-<code>SB</code>: Static base pointer: global symbols.
-</li>
-
-<li>
-<code>SP</code>: Stack pointer: top of stack.
-</li>
-
-</ul>
-
-<p>
-All user-defined symbols are written as offsets to the pseudo-registers
-<code>FP</code> (arguments and locals) and <code>SB</code> (globals).
+Some symbols, such as <code>PC</code>, <code>R0</code> and <code>SP</code>, are predeclared and refer to registers.
+There are two other predeclared symbols, <code>SB</code> (static base) and <code>FP</code> (frame pointer).
+All user-defined symbols other than jump labels are written as offsets to these pseudo-registers.
 </p>

 <p>
 The <code>SB</code> pseudo-register can be thought of as the origin of memory, so the symbol <code>foo(SB)</code>
 is the name <code>foo</code> as an address in memory.
 This form is used to name global functions and data.
-Adding <code>&lt;&gt;</code> to the name, as in <span style="white-space: nowrap"><code>foo&lt;&gt;(SB)</code></span>, makes the name
+Adding <code>&lt;&gt;</code> to the name, as in <code>foo&lt;&gt;(SB)</code>, makes the name
 visible only in the current source file, like a top-level <code>static</code> declaration in a C file.
-Adding an offset to the name refers to that offset from the symbol's address, so
-<code>foo+4(SB)</code> is four bytes past the start of <code>foo</code>.
 </p>

 <p>
@@ -185,19 +128,9 @@ used to refer to function arguments.
 The compilers maintain a virtual frame pointer and refer to the arguments on the stack as offsets from that pseudo-register.
 Thus <code>0(FP)</code> is the first argument to the function,
 <code>8(FP)</code> is the second (on a 64-bit machine), and so on.
-However, when referring to a function argument this way, it is necessary to place a name
+When referring to a function argument this way, it is conventional to place the name
 at the beginning, as in <code>first_arg+0(FP)</code> and <code>second_arg+8(FP)</code>.
-(The meaning of the offset—offset from the frame pointer—distinct
-from its use with <code>SB</code>, where it is an offset from the symbol.)
-The assembler enforces this convention, rejecting plain <code>0(FP)</code> and <code>8(FP)</code>.
-The actual name is semantically irrelevant but should be used to document
-the argument's name.
-It is worth stressing that <code>FP</code> is always a
-pseudo-register, not a hardware
-register, even on architectures with a hardware frame pointer.
-</p>
-
-<p>
+Some of the assemblers enforce this convention, rejecting plain <code>0(FP)</code> and <code>8(FP)</code>.
 For assembly functions with Go prototypes, <code>go</code> <code>vet</code> will check that the argument names
 and offsets match.
 On 32-bit systems, the low and high 32 bits of a 64-bit value are distinguished by adding
@@ -212,53 +145,13 @@ prepared for function calls.
 It points to the top of the local stack frame, so references should use negative offsets
 in the range [−framesize, 0):
 <code>x-8(SP)</code>, <code>y-4(SP)</code>, and so on.
-</p>
-
-<p>
-On architectures with a hardware register named <code>SP</code>,
-the name prefix distinguishes
-references to the virtual stack pointer from references to the architectural
-<code>SP</code> register.
-That is, <code>x-8(SP)</code> and <code>-8(SP)</code>
-are different memory locations:
-the first refers to the virtual stack pointer pseudo-register,
-while the second refers to the
+On architectures with a real register named <code>SP</code>, the name prefix distinguishes
+references to the virtual stack pointer from references to the architectural <code>SP</code> register.
+That is, <code>x-8(SP)</code> and <code>-8(SP)</code> are different memory locations:
+the first refers to the virtual stack pointer pseudo-register, while the second refers to the
 hardware's <code>SP</code> register.
 </p>

-<p>
-On machines where <code>SP</code> and <code>PC</code> are
-traditionally aliases for a physical, numbered register,
-in the Go assembler the names <code>SP</code> and <code>PC</code>
-are still treated specially;
-for instance, references to <code>SP</code> require a symbol,
-much like <code>FP</code>.
-To access the actual hardware register use the true <code>R</code> name.
-For example, on the ARM architecture the hardware
-<code>SP</code> and <code>PC</code> are accessible as
-<code>R13</code> and <code>R15</code>.
-</p>
-
-<p>
-Branches and direct jumps are always written as offsets to the PC, or as
-jumps to labels:
-</p>
-
-<pre>
-label:
-	MOVW $0, R1
-	JMP label
-</pre>
-
-<p>
-Each label is visible only within the function in which it is defined.
-It is therefore permitted for multiple functions in a file to define
-and use the same label names.
-Direct jumps and call instructions can target text symbols,
-such as <code>name(SB)</code>, but not offsets from symbols,
-such as <code>name+4(SB)</code>.
-</p>
-
 <p>
 Instructions, registers, and assembler directives are always in UPPER CASE to remind you
 that assembly programming is a fraught endeavor.
@@ -419,17 +312,11 @@ This data contains no pointers and therefore does not need to be
 scanned by the garbage collector.
 </li>
 <li>
-<code>WRAPPER</code> = 32
+<code>WRAPPER</code>  = 32
 <br>
 (For <code>TEXT</code> items.)
 This is a wrapper function and should not count as disabling <code>recover</code>.
 </li>
-<li>
-<code>NEEDCTXT</code> = 64
-<br>
-(For <code>TEXT</code> items.)
-This function is a closure so it uses its incoming context register.
-</li>
 </ul>

 <h3 id="runtime">Runtime Coordination</h3>
@@ -463,11 +350,7 @@ live pointers in its arguments, results, and local stack frame.
 For an assembly function with no pointer results and
 either no local stack frame or no function calls,
 the only requirement is to define a Go prototype for the function
-in a Go source file in the same package. The name of the assembly
-function must not contain the package name component (for example,
-function <code>Syscall</code> in package <code>syscall</code> should
-use the name <code>·Syscall</code> instead of the equivalent name
-<code>syscall·Syscall</code> in its <code>TEXT</code> directive).
+in a Go source file in the same package.
 For more complex situations, explicit annotation is needed.
 These annotations use pseudo-instructions defined in the standard
 <code>#include</code> file <code>funcdata.h</code>.
@@ -510,72 +393,46 @@ the stack pointer may change during any function call:
 even pointers to stack data must not be kept in local variables.
 </p>

-<p>
-Assembly functions should always be given Go prototypes,
-both to provide pointer information for the arguments and results
-and to let <code>go</code> <code>vet</code> check that
-the offsets being used to access them are correct.
-</p>
-
 <h2 id="architectures">Architecture-specific details</h2>

 <p>
 It is impractical to list all the instructions and other details for each machine.
-To see what instructions are defined for a given machine, say ARM,
-look in the source for the <code>obj</code> support library for
-that architecture, located in the directory <code>src/cmd/internal/obj/arm</code>.
-In that directory is a file <code>a.out.go</code>; it contains
-a long list of constants starting with <code>A</code>, like this:
+To see what instructions are defined for a given machine, say 32-bit Intel x86,
+look in the top-level header file for the corresponding linker, in this case <code>8l</code>.
+That is, the file <code>$GOROOT/src/cmd/8l/8.out.h</code> contains a C enumeration, called <code>as</code>,
+of the instructions and their spellings as known to the assembler and linker for that architecture.
+In that file you'll find a declaration that begins
 </p>

 <pre>
-const (
-	AAND = obj.ABaseARM + obj.A_ARCHSPECIFIC + iota
-	AEOR
-	ASUB
-	ARSB
-	AADD
+enum	as
+{
+	AXXX,
+	AAAA,
+	AAAD,
+	AAAM,
+	AAAS,
+	AADCB,
 	...
 </pre>

 <p>
-This is the list of instructions and their spellings as known to the assembler and linker for that architecture.
-Each instruction begins with an initial capital <code>A</code> in this list, so <code>AAND</code>
-represents the bitwise and instruction,
-<code>AND</code> (without the leading <code>A</code>),
-and is written in assembly source as <code>AND</code>.
-The enumeration is mostly in alphabetical order.
-(The architecture-independent <code>AXXX</code>, defined in the
-<code>cmd/internal/obj</code> package,
-represents an invalid instruction).
-The sequence of the <code>A</code> names has nothing to do with the actual
-encoding of the machine instructions.
-The <code>cmd/internal/obj</code> package takes care of that detail.
-</p>
-
-<p>
-The instructions for both the 386 and AMD64 architectures are listed in
-<code>cmd/internal/obj/x86/a.out.go</code>.
-</p>
-
-<p>
-The architectures share syntax for common addressing modes such as
-<code>(R1)</code> (register indirect),
-<code>4(R1)</code> (register indirect with offset), and
-<code>$foo(SB)</code> (absolute address).
-The assembler also supports some (not necessarily all) addressing modes
-specific to each architecture.
-The sections below list these.
+Each instruction begins with a  initial capital <code>A</code> in this list, so <code>AADCB</code>
+represents the <code>ADCB</code> (add carry byte) instruction.
+The enumeration is in alphabetical order, plus some late additions (<code>AXXX</code> occupies
+the zero slot as an invalid instruction).
+The sequence has nothing to do with the actual encoding of the machine instructions.
+Again, the linker takes care of that detail.
 </p>

 <p>
 One detail evident in the examples from the previous sections is that data in the instructions flows from left to right:
 <code>MOVQ</code> <code>$0,</code> <code>CX</code> clears <code>CX</code>.
-This rule applies even on architectures where the conventional notation uses the opposite direction.
+This convention applies even on architectures where the usual mode is the opposite direction.
 </p>

 <p>
-Here follow some descriptions of key Go-specific details for the supported architectures.
+Here follows some descriptions of key Go-specific details for the supported architectures.
 </p>

 <h3 id="x86">32-bit Intel 386</h3>
@@ -584,11 +441,11 @@ Here follow some descriptions of key Go-specific details for the supported archi
 The runtime pointer to the <code>g</code> structure is maintained
 through the value of an otherwise unused (as far as Go is concerned) register in the MMU.
 A OS-dependent macro <code>get_tls</code> is defined for the assembler if the source includes
-a special header, <code>go_asm.h</code>:
+an architecture-dependent header file, like this:
 </p>

 <pre>
-#include "go_asm.h"
+#include "zasm_GOOS_GOARCH.h"
 </pre>

 <p>
@@ -601,48 +458,21 @@ The sequence to load <code>g</code> and <code>m</code> using <code>CX</code> loo
 <pre>
 get_tls(CX)
 MOVL	g(CX), AX     // Move g into AX.
-MOVL	g_m(AX), BX   // Move g.m into BX.
+MOVL	g_m(AX), BX   // Move g->m into BX.
 </pre>

-<p>
-Addressing modes:
-</p>
-
-<ul>
-
-<li>
-<code>(DI)(BX*2)</code>: The location at address <code>DI</code> plus <code>BX*2</code>.
-</li>
-
-<li>
-<code>64(DI)(BX*2)</code>: The location at address <code>DI</code> plus <code>BX*2</code> plus 64.
-These modes accept only 1, 2, 4, and 8 as scale factors.
-</li>
-
-</ul>
-
-<p>
-When using the compiler and assembler's
-<code>-dynlink</code> or <code>-shared</code> modes,
-any load or store of a fixed memory location such as a global variable
-must be assumed to overwrite <code>CX</code>.
-Therefore, to be safe for use with these modes,
-assembly sources should typically avoid CX except between memory references.
-</p>
-
 <h3 id="amd64">64-bit Intel 386 (a.k.a. amd64)</h3>

 <p>
-The two architectures behave largely the same at the assembler level.
-Assembly code to access the <code>m</code> and <code>g</code>
-pointers on the 64-bit version is the same as on the 32-bit 386,
-except it uses <code>MOVQ</code> rather than <code>MOVL</code>:
+The assembly code to access the <code>m</code> and <code>g</code>
+pointers is the same as on the 386, except it uses <code>MOVQ</code> rather than
+<code>MOVL</code>:
 </p>

 <pre>
 get_tls(CX)
 MOVQ	g(CX), AX     // Move g into AX.
-MOVQ	g_m(AX), BX   // Move g.m into BX.
+MOVQ	g_m(AX), BX   // Move g->m into BX.
 </pre>

 <h3 id="arm">ARM</h3>
@@ -679,203 +509,6 @@ The name <code>SP</code> always refers to the virtual stack pointer described ea
 For the hardware register, use <code>R13</code>.
 </p>

-<p>
-Condition code syntax is to append a period and the one- or two-letter code to the instruction,
-as in <code>MOVW.EQ</code>.
-Multiple codes may be appended: <code>MOVM.IA.W</code>.
-The order of the code modifiers is irrelevant.
-</p>
-
-<p>
-Addressing modes:
-</p>
-
-<ul>
-
-<li>
-<code>R0-&gt;16</code>
-<br>
-<code>R0&gt;&gt;16</code>
-<br>
-<code>R0&lt;&lt;16</code>
-<br>
-<code>R0@&gt;16</code>:
-For <code>&lt;&lt;</code>, left shift <code>R0</code> by 16 bits.
-The other codes are <code>-&gt;</code> (arithmetic right shift),
-<code>&gt;&gt;</code> (logical right shift), and
-<code>@&gt;</code> (rotate right).
-</li>
-
-<li>
-<code>R0-&gt;R1</code>
-<br>
-<code>R0&gt;&gt;R1</code>
-<br>
-<code>R0&lt;&lt;R1</code>
-<br>
-<code>R0@&gt;R1</code>:
-For <code>&lt;&lt;</code>, left shift <code>R0</code> by the count in <code>R1</code>.
-The other codes are <code>-&gt;</code> (arithmetic right shift),
-<code>&gt;&gt;</code> (logical right shift), and
-<code>@&gt;</code> (rotate right).
-
-</li>
-
-<li>
-<code>[R0,g,R12-R15]</code>: For multi-register instructions, the set comprising
-<code>R0</code>, <code>g</code>, and <code>R12</code> through <code>R15</code> inclusive.
-</li>
-
-<li>
-<code>(R5, R6)</code>: Destination register pair.
-</li>
-
-</ul>
-
-<h3 id="arm64">ARM64</h3>
-
-<p>
-The ARM64 port is in an experimental state.
-</p>
-
-<p>
-Instruction modifiers are appended to the instruction following a period.
-The only modifiers are <code>P</code> (postincrement) and <code>W</code>
-(preincrement):
-<code>MOVW.P</code>, <code>MOVW.W</code>
-</p>
-
-<p>
-Addressing modes:
-</p>
-
-<ul>
-
-<li>
-<code>(R5, R6)</code>: Register pair for <code>LDP</code>/<code>STP</code>.
-</li>
-
-</ul>
-
-<h3 id="ppc64">64-bit PowerPC, a.k.a. ppc64</h3>
-
-<p>
-The 64-bit PowerPC port is in an experimental state.
-</p>
-
-<p>
-Addressing modes:
-</p>
-
-<ul>
-
-<li>
-<code>(R5)(R6*1)</code>: The location at <code>R5</code> plus <code>R6</code>. It is a scaled
-mode as on the x86, but the only scale allowed is <code>1</code>.
-</li>
-
-<li>
-<code>(R5+R6)</code>: Alias for (R5)(R6*1)
-</li>
-
-</ul>
-
-<h3 id="s390x">IBM z/Architecture, a.k.a. s390x</h3>
-
-<p>
-The registers <code>R10</code> and <code>R11</code> are reserved.
-The assembler uses them to hold temporary values when assembling some instructions.
-</p>
-
-<p>
-<code>R13</code> points to the <code>g</code> (goroutine) structure.
-This register must be referred to as <code>g</code>; the name <code>R13</code> is not recognized.
-</p>
-
-<p>
-<code>R15</code> points to the stack frame and should typically only be accessed using the
-virtual registers <code>SP</code> and <code>FP</code>.
-</p>
-
-<p>
-Load- and store-multiple instructions operate on a range of registers.
-The range of registers is specified by a start register and an end register.
-For example, <code>LMG</code> <code>(R9),</code> <code>R5,</code> <code>R7</code> would load
-<code>R5</code>, <code>R6</code> and <code>R7</code> with the 64-bit values at
-<code>0(R9)</code>, <code>8(R9)</code> and <code>16(R9)</code> respectively.
-</p>
-
-<p>
-Storage-and-storage instructions such as <code>MVC</code> and <code>XC</code> are written
-with the length as the first argument.
-For example, <code>XC</code> <code>$8,</code> <code>(R9),</code> <code>(R9)</code> would clear
-eight bytes at the address specified in <code>R9</code>.
-</p>
-
-<p>
-If a vector instruction takes a length or an index as an argument then it will be the
-first argument.
-For example, <code>VLEIF</code> <code>$1,</code> <code>$16,</code> <code>V2</code> will load
-the value sixteen into index one of <code>V2</code>.
-Care should be taken when using vector instructions to ensure that they are available at
-runtime.
-To use vector instructions a machine must have both the vector facility (bit 129 in the
-facility list) and kernel support.
-Without kernel support a vector instruction will have no effect (it will be equivalent
-to a <code>NOP</code> instruction).
-</p>
-
-<p>
-Addressing modes:
-</p>
-
-<ul>
-
-<li>
-<code>(R5)(R6*1)</code>: The location at <code>R5</code> plus <code>R6</code>.
-It is a scaled mode as on the x86, but the only scale allowed is <code>1</code>.
-</li>
-
-</ul>
-
-<h3 id="mips">MIPS, MIPS64</h3>
-
-<p>
-General purpose registers are named <code>R0</code> through <code>R31</code>,
-floating point registers are <code>F0</code> through <code>F31</code>.
-</p>
-
-<p>
-<code>R30</code> is reserved to point to <code>g</code>.
-<code>R23</code> is used as a temporary register.
-</p>
-
-<p>
-In a <code>TEXT</code> directive, the frame size <code>$-4</code> for MIPS or
-<code>$-8</code> for MIPS64 instructs the linker not to save <code>LR</code>.
-</p>
-
-<p>
-<code>SP</code> refers to the virtual stack pointer.
-For the hardware register, use <code>R29</code>.
-</p>
-
-<p>
-Addressing modes:
-</p>
-
-<ul>
-
-<li>
-<code>16(R1)</code>: The location at <code>R1</code> plus 16.
-</li>
-
-<li>
-<code>(R1)</code>: Alias for <code>0(R1)</code>.
-</li>
-
-</ul>
-
 <h3 id="unsupported_opcodes">Unsupported opcodes</h3>

 <p>
@@ -894,17 +527,11 @@ Here's how the 386 runtime defines the 64-bit atomic load function.
 // uint64 atomicload64(uint64 volatile* addr);
 // so actually
 // void atomicload64(uint64 *res, uint64 volatile *addr);
-TEXT runtime·atomicload64(SB), NOSPLIT, $0-12
+TEXT runtime·atomicload64(SB), NOSPLIT, $0-8
 	MOVL	ptr+0(FP), AX
-	TESTL	$7, AX
-	JZ	2(PC)
-	MOVL	0, AX // crash with nil ptr deref
 	LEAL	ret_lo+4(FP), BX
-	// MOVQ (%EAX), %MM0
-	BYTE $0x0f; BYTE $0x6f; BYTE $0x00
-	// MOVQ %MM0, 0(%EBX)
-	BYTE $0x0f; BYTE $0x7f; BYTE $0x03
-	// EMMS
-	BYTE $0x0F; BYTE $0x77
+	BYTE $0x0f; BYTE $0x6f; BYTE $0x00	// MOVQ (%EAX), %MM0
+	BYTE $0x0f; BYTE $0x7f; BYTE $0x03	// MOVQ %MM0, 0(%EBX)
+	BYTE $0x0F; BYTE $0x77			// EMMS
 	RET
 </pre>
--- a/doc/cmd.html
+++ b/doc/cmd.html
@@ -22,7 +22,7 @@ using the go <code>tool</code> subcommand, such as <code>go tool vet</code>.
 This style of invocation allows, for instance, checking a single source file
 rather than an entire package: <code>go tool vet myprogram.go</code> as
 compared to <code>go vet mypackage</code>.
-Some of the commands, such as <code>pprof</code>, are accessible only through
+Some of the commands, such as <code>yacc</code>, are accessible only through
 the go <code>tool</code> subcommand.
 </p>

@@ -62,7 +62,7 @@ details.
 </tr>

 <tr>
-<td><a href="/cmd/cover/">cover</a></td>
+<td><a href="//godoc.org/golang.org/x/tools/cmd/cover/">cover</a></td>
 <td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
 <td>Cover is a program for creating and analyzing the coverage profiles
 generated by <code>"go test -coverprofile"</code>.</td>
@@ -89,12 +89,18 @@ gofmt</a> command with more general options.</td>
 </tr>

 <tr>
-<td><a href="/cmd/vet/">vet</a></td>
+<td><a href="//godoc.org/golang.org/x/tools/cmd/vet/">vet</a></td>
 <td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
 <td>Vet examines Go source code and reports suspicious constructs, such as Printf
 calls whose arguments do not align with the format string.</td>
 </tr>

+<tr>
+<td><a href="/cmd/yacc/">yacc</a></td>
+<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
+<td>Yacc is a version of yacc that generates parsers implemented in Go.</td>
+</tr>
+
 </table>

 <p>
--- a/doc/code.html
+++ b/doc/code.html
@@ -24,31 +24,21 @@ A similar explanation is available as a

 <h2 id="Organization">Code organization</h2>

-<h3 id="Overview">Overview</h3>
-
-<ul>
-	<li>Go programmers typically keep all their Go code in a single <i>workspace</i>.</li>
-	<li>A workspace contains many version control <i>repositories</i>
-	    (managed by Git, for example).</li>
-	<li>Each repository contains one or more <i>packages</i>.</li>
-	<li>Each package consists of one or more Go source files in a single directory.</li>
-	<li>The path to a package's directory determines its <i>import path</i>.</li>
-</ul>
-
-<p>
-Note that this differs from other programming environments in which every
-project has a separate workspace and workspaces are closely tied to version
-control repositories.
-</p>
-
 <h3 id="Workspaces">Workspaces</h3>

 <p>
+The <code>go</code> tool is designed to work with open source code maintained
+in public repositories. Although you don't need to publish your code, the model
+for how the environment is set up works the same whether you do or not.
+</p>
+
+<p>
+Go code must be kept inside a <i>workspace</i>.
 A workspace is a directory hierarchy with three directories at its root:
 </p>

 <ul>
-<li><code>src</code> contains Go source files,
+<li><code>src</code> contains Go source files organized into packages (one package per directory),
 <li><code>pkg</code> contains package objects, and
 <li><code>bin</code> contains executable commands.
 </ul>
@@ -87,25 +77,16 @@ src/
 	stringutil/
 	    reverse.go             # package source
 	    reverse_test.go        # test source
-    <a href="https://golang.org/x/image/">golang.org/x/image/</a>
-        .git/                      # Git repository metadata
-	bmp/
-	    reader.go              # package source
-	    writer.go              # package source
-    ... (many more repositories and packages omitted) ...
 </pre>

 <p>
-The tree above shows a workspace containing two repositories
-(<code>example</code> and <code>image</code>).
-The <code>example</code> repository contains two commands (<code>hello</code>
-and <code>outyet</code>) and one library (<code>stringutil</code>).
-The <code>image</code> repository contains the <code>bmp</code> package
-and <a href="https://godoc.org/golang.org/x/image">several others</a>.
+This workspace contains one repository (<code>example</code>)
+comprising two commands (<code>hello</code> and <code>outyet</code>)
+and one library (<code>stringutil</code>).
 </p>

 <p>
-A typical workspace contains many source repositories containing many
+A typical workspace would contain many source repositories containing many
 packages and commands. Most Go programmers keep <i>all</i> their Go source code
 and dependencies in a single workspace.
 </p>
@@ -120,26 +101,21 @@ We will discuss the distinction <a href="#PackageNames">later</a>.

 <p>
 The <code>GOPATH</code> environment variable specifies the location of your
-workspace. It defaults to a directory named <code>go</code> inside your home directory,
-so <code>$HOME/go</code> on Unix,
-<code>$home/go</code> on Plan 9,
-and <code>%USERPROFILE%\go</code> (usually <code>C:\Users\YourName\go</code>) on Windows.
+workspace. It is likely the only environment variable you'll need to set
+when developing Go code.
 </p>

 <p>
-If you would like to work in a different location, you will need to
-<a href="https://golang.org/wiki/SettingGOPATH">set <code>GOPATH</code></a>
-to the path to that directory.
-(Another common setup is to set <code>GOPATH=$HOME</code>.)
-Note that <code>GOPATH</code> must <b>not</b> be the
+To get started, create a workspace directory and set <code>GOPATH</code>
+accordingly. Your workspace can be located wherever you like, but we'll use
+<code>$HOME/go</code> in this document. Note that this must <b>not</b> be the
 same path as your Go installation.
 </p>

-<p>
-The command <code>go</code> <code>env</code> <code>GOPATH</code>
-prints the effective current <code>GOPATH</code>;
-it prints the default location if the environment variable is unset.
-</p>
+<pre>
+$ <b>mkdir $HOME/go</b>
+$ <b>export GOPATH=$HOME/go</b>
+</pre>

 <p>
 For convenience, add the workspace's <code>bin</code> subdirectory
@@ -147,42 +123,14 @@ to your <code>PATH</code>:
 </p>

 <pre>
-$ <b>export PATH=$PATH:$(go env GOPATH)/bin</b>
+$ <b>export PATH=$PATH:$GOPATH/bin</b>
 </pre>

-<p>
-The scripts in the rest of this document use <code>$GOPATH</code>
-instead of <code>$(go env GOPATH)</code> for brevity.
-To make the scripts run as written
-if you have not set GOPATH,
-you can substitute $HOME/go in those commands
-or else run:
-</p>

-<pre>
-$ <b>export GOPATH=$(go env GOPATH)</b>
-</pre>
+<h3 id="PackagePaths">Package paths</h3>

 <p>
-To learn more about the <code>GOPATH</code> environment variable, see
-<a href="/cmd/go/#hdr-GOPATH_environment_variable"><code>'go help gopath'</code></a>.
-</p>
-
-<p>
-To use a custom workspace location,
-<a href="https://golang.org/wiki/SettingGOPATH">set the <code>GOPATH</code> environment variable</a>.
-</p>
-
-<h3 id="ImportPaths">Import paths</h3>
-
-<p>
-An <i>import path</i> is a string that uniquely identifies a package.
-A package's import path corresponds to its location inside a workspace
-or in a remote repository (explained below).
-</p>
-
-<p>
-The packages from the standard library are given short import paths such as
+The packages from the standard library are given short paths such as
 <code>"fmt"</code> and <code>"net/http"</code>.
 For your own packages, you must choose a base path that is unlikely to
 collide with future additions to the standard library or other external
@@ -306,7 +254,7 @@ optional: you do not need to use source control to write Go code.
 <pre>
 $ <b>cd $GOPATH/src/github.com/user/hello</b>
 $ <b>git init</b>
-Initialized empty Git repository in /home/user/work/src/github.com/user/hello/.git/
+Initialized empty Git repository in /home/user/go/src/github.com/user/hello/.git/
 $ <b>git add hello.go</b>
 $ <b>git commit -m "initial commit"</b>
 [master (root-commit) 0b4507d] initial commit
@@ -630,7 +578,7 @@ import "github.com/golang/example/stringutil"
 <p>
 This convention is the easiest way to make your Go packages available for
 others to use.
-The <a href="//golang.org/wiki/Projects">Go Wiki</a>
+The <a href="//code.google.com/p/go-wiki/wiki/Projects">Go Wiki</a>
 and <a href="//godoc.org/">godoc.org</a>
 provide lists of external Go projects.
 </p>
@@ -679,5 +627,5 @@ The official mailing list for discussion of the Go language is

 <p>
 Report bugs using the
-<a href="//golang.org/issue">Go issue tracker</a>.
+<a href="//code.google.com/p/go/issues/list">Go issue tracker</a>.
 </p>
--- a/doc/codewalk/codewalk.js
+++ b/doc/codewalk/codewalk.js
@@ -1,4 +1,4 @@
-// Copyright 2010 The Go Authors. All rights reserved.
+// Copyright 2010 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.

--- a/doc/codewalk/codewalk.xml
+++ b/doc/codewalk/codewalk.xml
@@ -91,7 +91,7 @@

 	The full address syntax is summarized in this table
 	(an excerpt of Table II from
-	<a href="https://9p.io/sys/doc/sam/sam.html">The text editor <code>sam</code></a>):
+	<a href="http://plan9.bell-labs.com/sys/doc/sam/sam.html">The text editor <code>sam</code></a>):
 	<br/><br/>

 	<table>
--- a/doc/codewalk/markov.go
+++ b/doc/codewalk/markov.go
@@ -1,4 +1,4 @@
-// Copyright 2011 The Go Authors. All rights reserved.
+// Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

--- a/doc/codewalk/markov.xml
+++ b/doc/codewalk/markov.xml
@@ -1,5 +1,5 @@
 <!--
-Copyright 2011 The Go Authors. All rights reserved.
+Copyright 2011 The Go Authors.  All rights reserved.
 Use of this source code is governed by a BSD-style
 license that can be found in the LICENSE file.
 -->
--- a/doc/conduct.html
+++ b/doc/conduct.html
@@ -1,260 +0,0 @@
-<!--{
-	"Title": "Go Community Code of Conduct",
-	"Path":  "/conduct",
-	"Template": true
-}-->
-
-<style>
-ul {
-	max-width: 800px;
-}
-ul ul {
-	margin: 0 0 5px;
-}
-</style>
-
-<h2 id="about">About the Code of Conduct</h2>
-
-<h3 id="why">Why have a Code of Conduct?</h3>
-
-<p>
-Online communities include people from many different backgrounds.
-The Go contributors are committed to providing a friendly, safe and welcoming
-environment for all, regardless of age, disability, gender, nationality,
-ethnicity, religion, sexuality, or similar personal characteristic.
-</p>
-
-<p>
-The first goal of the Code of Conduct is to specify a baseline standard
-of behavior so that people with different social values and communication
-styles can talk about Go effectively, productively, and respectfully.
-</p>
-
-<p>
-The second goal is to provide a mechanism for resolving conflicts in the
-community when they arise.
-</p>
-
-<p>
-The third goal of the Code of Conduct is to make our community welcoming to
-people from different backgrounds.
-Diversity is critical to the project; for Go to be successful, it needs
-contributors and users from all backgrounds.
-(See <a href="https://blog.golang.org/open-source">Go, Open Source, Community</a>.)
-</p>
-
-<p>
-With that said, a healthy community must allow for disagreement and debate.
-The Code of Conduct is not a mechanism for people to silence others with whom
-they disagree.
-</p>
-
-<h3 id="spaces">Where does the Code of Conduct apply?</h3>
-
-<p>
-If you participate in or contribute to the Go ecosystem in any way,
-you are encouraged to follow the Code of Conduct while doing so.
-</p>
-
-<p>
-Explicit enforcement of the Code of Conduct applies to the
-official forums operated by the Go project (“Go spaces”):
-</p>
-
-<ul>
-    <li>The official <a href="https://github.com/golang/">GitHub projects</a>
-        and <a href="https://go-review.googlesource.com/">code reviews</a>.
-    <li>The <a href="https://groups.google.com/group/golang-nuts">golang-nuts</a> and
-        <a href="https://groups.google.com/group/golang-dev">golang-dev</a> mailing lists.
-<li>The #go-nuts IRC channel on Freenode.
-</ul>
-
-<p>
-Other Go groups (such as conferences, meetups, and other unofficial forums) are
-encouraged to adopt this Code of Conduct. Those groups must provide their own
-moderators and/or working group (see below).
-</p>
-
-<h2 id="values">Gopher values</h2>
-
-<p>
-These are the values to which people in the Go community (“Gophers”) should aspire.
-</p>
-
-<ul>
-<li>Be friendly and welcoming
-<li>Be patient
-    <ul>
-    <li>Remember that people have varying communication styles and that not
-        everyone is using their native language.
-        (Meaning and tone can be lost in translation.)
-    </ul>
-<li>Be thoughtful
-    <ul>
-    <li>Productive communication requires effort.
-        Think about how your words will be interpreted.
-    <li>Remember that sometimes it is best to refrain entirely from commenting.
-    </ul>
-<li>Be respectful
-    <ul>
-    <li>In particular, respect differences of opinion.
-    </ul>
-<li>Be charitable
-    <ul>
-    <li>Interpret the arguments of others in good faith, do not seek to disagree.
-    <li>When we do disagree, try to understand why.
-    </ul>
-<li>Avoid destructive behavior:
-    <ul>
-    <li>Derailing: stay on topic; if you want to talk about something else,
-        start a new conversation.
-    <li>Unconstructive criticism: don't merely decry the current state of affairs;
-        offer—or at least solicit—suggestions as to how things may be improved.
-    <li>Snarking (pithy, unproductive, sniping comments)
-    <li>Discussing potentially offensive or sensitive issues;
-        this all too often leads to unnecessary conflict.
-    <li>Microaggressions: brief and commonplace verbal, behavioral and
-        environmental indignities that communicate hostile, derogatory or negative
-        slights and insults to a person or group.
-    </ul>
-</ul>
-
-<p>
-People are complicated.
-You should expect to be misunderstood and to misunderstand others;
-when this inevitably occurs, resist the urge to be defensive or assign blame.
-Try not to take offense where no offense was intended.
-Give people the benefit of the doubt.
-Even if the intent was to provoke, do not rise to it.
-It is the responsibility of <i>all parties</i> to de-escalate conflict when it arises.
-</p>
-
-<h2 id="unwelcome_behavior">Unwelcome behavior</h2>
-
-<p>
-These actions are explicitly forbidden in Go spaces:
-</p>
-
-<ul>
-<li>Insulting, demeaning, hateful, or threatening remarks.
-<li>Discrimination based on age, disability, gender, nationality, race,
-    religion, sexuality, or similar personal characteristic.
-<li>Bullying or systematic harassment.
-<li>Unwelcome sexual advances.
-<li>Incitement to any of these.
-</ul>
-
-<h2 id="moderation">Moderation</h2>
-
-<p>
-The Go spaces are not free speech venues; they are for discussion about Go.
-Each of these spaces have their own moderators.
-</p>
-
-<p>
-When using the official Go spaces you should act in the spirit of the “Gopher
-values”.
-If a reported conflict cannot be resolved amicably, the CoC Working Group
-may make a recommendation to the relevant forum moderators.
-</p>
-
-<p>
-CoC Working Group members and forum moderators are held to a higher standard than other community members.
-If a working group member or moderator creates an inappropriate situation, they
-should expect less leeway than others, and should expect to be removed from
-their position if they cannot adhere to the CoC.
-</p>
-
-<p>
-Complaints about working group member or moderator actions must be handled 
-using the reporting process below.
-</p>
-
-<h2 id="reporting">Reporting issues</h2>
-
-<p>
-The Code of Conduct Working Group is a group of people that represent the Go
-community. They are responsible for handling conduct-related issues.
-Their purpose is to de-escalate conflicts and try to resolve issues to the
-satisfaction of all parties. They are:
-</p>
-
-<ul>
-	<li>Aditya Mukerjee &lt;dev@chimeracoder.net&gt;
-	<li>Andrew Gerrand &lt;adg@golang.org&gt;
-	<li>Peggy Li &lt;peggyli.224@gmail.com&gt;
-	<li>Sarah Adams &lt;sadams.codes@gmail.com&gt;
-	<li>Steve Francia &lt;steve.francia@gmail.com&gt;
-	<li>Verónica López &lt;gveronicalg@gmail.com&gt;
-</ul>
-
-<p>
-If you encounter a conduct-related issue, you should report it to the
-Working Group using the process described below.
-<b>Do not</b> post about the issue publicly or try to rally sentiment against a
-particular individual or group.
-</p>
-
-<ul>
-<li>Mail <a href="mailto:conduct@golang.org">conduct@golang.org</a>.
-    <ul>
-    <li>Your message will reach the Working Group.
-    <li>Reports are confidential within the Working Group.
-    <li>You may contact a member of the group directly if you do not feel
-        comfortable contacting the group as a whole. That member will then raise
-        the issue with the Working Group as a whole, preserving the privacy of the
-        reporter (if desired).
-    <li>If your report concerns a member of the Working Group they will be recused
-        from Working Group discussions of the report.
-    <li>The Working Group will strive to handle reports with discretion and
-        sensitivity, to protect the privacy of the involved parties,
-        and to avoid conflicts of interest.
-    </ul>
-<li>You should receive a response within 48 hours (likely sooner).
-    (Should you choose to contact a single Working Group member,
-    it may take longer to receive a response.)
-<li>The Working Group will meet to review the incident and determine what happened.
-    <ul>
-    <li>With the permission of person reporting the incident, the Working Group
-        may reach out to other community members for more context.
-    </ul>
-<li>The Working Group will reach a decision as to how to act. These may include:
-    <ul>
-    <li>Nothing.
-    <li>Passing the report along to the offender.
-    <li>A recommendation of action to the relevant forum moderators.
-    </ul>
-<li>The Working Group will reach out to the original reporter to let them know
-    the decision.
-<li>Appeals to the decision may be made to the Working Group,
-    or to any of its members directly.
-</ul>
-
-<p>
-<b>Note that the goal of the Code of Conduct and the Working Group is to resolve
-conflicts in the most harmonious way possible.</b>
-We hope that in most cases issues may be resolved through polite discussion and
-mutual agreement.
-</p>
-
-<p>
-Changes to the Code of Conduct (including to the members of the Working Group)
-should be proposed using the
-<a href="https://golang.org/s/proposal-process">change proposal process</a>.
-</p>
-
-<h2 id="summary">Summary</h2>
-
-<ul>
-<li>Treat everyone with respect and kindness.
-<li>Be thoughtful in how you communicate.
-<li>Don’t be destructive or inflammatory.
-<li>If you encounter an issue, please mail <a href="mailto:conduct@golang.org">conduct@golang.org</a>.
-</ul>
-
-<h3 id="acknowledgements">Acknowledgements</h3>
-
-<p>
-Parts of this document were derived from the Code of Conduct documents of the
-Django, FreeBSD, and Rust projects.
-</p>
--- a/doc/contrib.html
+++ b/doc/contrib.html
@@ -34,10 +34,6 @@ We encourage all Go users to subscribe to
 <p>A <a href="/doc/devel/release.html">summary</a> of the changes between Go releases. Notes for the major releases:</p>

 <ul>
-	<li><a href="/doc/go1.8">Go 1.8</a> <small>(February 2017)</small></li>
-	<li><a href="/doc/go1.7">Go 1.7</a> <small>(August 2016)</small></li>
-	<li><a href="/doc/go1.6">Go 1.6</a> <small>(February 2016)</small></li>
-	<li><a href="/doc/go1.5">Go 1.5</a> <small>(August 2015)</small></li>
 	<li><a href="/doc/go1.4">Go 1.4</a> <small>(December 2014)</small></li>
 	<li><a href="/doc/go1.3">Go 1.3</a> <small>(June 2014)</small></li>
 	<li><a href="/doc/go1.2">Go 1.2</a> <small>(December 2013)</small></li>
@@ -54,7 +50,7 @@ Go 1 matures.

 <h2 id="resources">Developer Resources</h2>

-<h3 id="source"><a href="https://golang.org/change">Source Code</a></h3>
+<h3 id="source"><a href="https://code.google.com/p/go/source">Source Code</a></h3>
 <p>Check out the Go source code.</p>

 <h3 id="golang-dev"><a href="https://groups.google.com/group/golang-dev">Developer</a> and
@@ -70,6 +66,9 @@ href="https://groups.google.com/group/golang-nuts">golang-nuts</a>.</p>
 <h3 id="golang-checkins"><a href="https://groups.google.com/group/golang-checkins">Checkins Mailing List</a></h3>
 <p>A mailing list that receives a message summarizing each checkin to the Go repository.</p>

+<h3 id="golang-bugs"><a href="https://groups.google.com/group/golang-bugs">Bugs Mailing List</a></h3>
+<p>A mailing list that receives each update to the Go <a href="//golang.org/issue">issue tracker</a>.</p>
+
 <h3 id="build_status"><a href="//build.golang.org/">Build Status</a></h3>
 <p>View the status of Go builds across the supported operating
 systems and architectures.</p>
@@ -77,13 +76,13 @@ systems and architectures.</p>

 <h2 id="howto">How you can help</h2>

-<h3><a href="//golang.org/issue">Reporting issues</a></h3>
+<h3><a href="https://code.google.com/p/go/issues">Reporting issues</a></h3>

 <p>
 If you spot bugs, mistakes, or inconsistencies in the Go project's code or
 documentation, please let us know by
-<a href="//golang.org/issue/new">filing a ticket</a>
-on our <a href="//golang.org/issue">issue tracker</a>.
+<a href="https://code.google.com/p/go/issues/entry">filing a ticket</a>
+on our <a href="https://code.google.com/p/go/issues">issue tracker</a>.
 (Of course, you should check it's not an existing issue before creating
 a new one.)
 </p>
@@ -92,18 +91,6 @@ a new one.)
 We pride ourselves on being meticulous; no issue is too small.
 </p>

-<p>
-Security-related issues should be reported to
-<a href="mailto:security@golang.org">security@golang.org</a>.<br>
-See the <a href="/security">security policy</a> for more details.
-</p>
-
-<p>
-Community-related issues should be reported to
-<a href="mailto:conduct@golang.org">conduct@golang.org</a>.<br>
-See the <a href="/conduct">Code of Conduct</a> for more details.
-</p>
-
 <h3><a href="/doc/contribute.html">Contributing code</a></h3>

 <p>
@@ -114,8 +101,8 @@ To get started, read these <a href="/doc/contribute.html">contribution
 guidelines</a> for information on design, testing, and our code review process.
 </p>
 <p>
-Check <a href="//golang.org/issue">the tracker</a> for 
+Check <a href="https://code.google.com/p/go/issues">the tracker</a> for 
 open issues that interest you. Those labeled
-<a href="https://github.com/golang/go/issues?q=is%3Aopen+is%3Aissue+label%3Ahelpwanted">helpwanted</a>
+<a href="https://code.google.com/p/go/issues/list?q=status=HelpWanted">HelpWanted</a>
 are particularly in need of outside help.
 </p>
--- a/doc/contribute.html
+++ b/doc/contribute.html
--- a/doc/debugging_with_gdb.html
+++ b/doc/debugging_with_gdb.html
@@ -4,8 +4,7 @@
 }-->

 <p><i>
-This applies to the standard toolchain (the <code>gc</code> Go
-compiler and tools). Gccgo has native gdb support.
+This applies to the <code>gc</code> toolchain. Gccgo has native gdb support.
 Besides this overview you might want to consult the
 <a href="http://sourceware.org/gdb/current/onlinedocs/gdb/">GDB manual</a>.
 </i></p>
@@ -50,14 +49,6 @@ when debugging, pass the flags <code>-gcflags "-N -l"</code> to the
 debugged.
 </p>

-<p>
-If you want to use gdb to inspect a core dump, you can trigger a dump
-on a program crash, on systems that permit it, by setting
-<code>GOTRACEBACK=crash</code> in the environment (see the
-<a href="/pkg/runtime/#hdr-Environment_Variables"> runtime package
-documentation</a> for more info).
-</p>
-
 <h3 id="Common_Operations">Common Operations</h3>

 <ul>
@@ -133,13 +124,13 @@ href="/src/runtime/runtime-gdb.py">src/runtime/runtime-gdb.py</a> in
 the Go source distribution. It depends on some special magic types
 (<code>hash&lt;T,U&gt;</code>) and variables (<code>runtime.m</code> and
 <code>runtime.g</code>) that the linker
-(<a href="/src/cmd/link/internal/ld/dwarf.go">src/cmd/link/internal/ld/dwarf.go</a>) ensures are described in
+(<a href="/src/cmd/ld/dwarf.c">src/cmd/ld/dwarf.c</a>) ensures are described in
 the DWARF code.
 </p>

 <p>
 If you're interested in what the debugging information looks like, run
-'<code>objdump -W a.out</code>' and browse through the <code>.debug_*</code>
+'<code>objdump -W 6.out</code>' and browse through the <code>.debug_*</code>
 sections.
 </p>

@@ -386,9 +377,7 @@ $3 = struct hchan&lt;*testing.T&gt;
 </pre>

 <p>
-That <code>struct hchan&lt;*testing.T&gt;</code> is the
-runtime-internal representation of a channel. It is currently empty,
-or gdb would have pretty-printed its contents.
+That <code>struct hchan&lt;*testing.T&gt;</code> is the runtime-internal representation of a channel.  It is currently empty, or gdb would have pretty-printed it's contents.
 </p>

 <p>
--- a/doc/devel/pre_go1.html
+++ b/doc/devel/pre_go1.html
@@ -1,455 +0,0 @@
-<!--{
-	"Title": "Pre-Go 1 Release History"
-}-->
-
-<p>
-This page summarizes the changes between stable releases of Go prior to Go 1.
-See the <a href="release.html">Release History</a> page for notes on recent releases.
-</p>
-
-<h2 id="r60">r60 (released 2011/09/07)</h2>
-
-<p>
-The r60 release corresponds to 
-<code><a href="weekly.html#2011-08-17">weekly.2011-08-17</a></code>.
-This section highlights the most significant changes in this release.
-For a more detailed summary, see the
-<a href="weekly.html#2011-08-17">weekly release notes</a>.
-For complete information, see the
-<a href="//code.google.com/p/go/source/list?r=release-branch.r60">Mercurial change list</a>.
-</p>
-
-<h3 id="r60.lang">Language</h3>
-
-<p>
-An "else" block is now required to have braces except if the body of the "else"
-is another "if". Since gofmt always puts those braces in anyway,
-gofmt-formatted programs will not be affected.
-To fix other programs, run gofmt.
-</p>
-
-<h3 id="r60.pkg">Packages</h3>
-
-<p>
-<a href="/pkg/http/">Package http</a>'s URL parsing and query escaping code
-(such as <code>ParseURL</code> and <code>URLEscape</code>) has been moved to
-the new <a href="/pkg/url/">url package</a>, with several simplifications to
-the names. Client code can be updated automatically with gofix.
-</p>
-
-<p>
-<a href="/pkg/image/">Package image</a> has had significant changes made to the
-<code>Pix</code> field of struct types such as
-<a href="/pkg/image/#RGBA">image.RGBA</a> and
-<a href="/pkg/image/#NRGBA">image.NRGBA</a>.
-The <a href="/pkg/image/#Image">image.Image</a> interface type has not changed,
-though, and you should not need to change your code if you don't explicitly
-refer to <code>Pix</code> fields. For example, if you decode a number of images
-using the <a href="/pkg/image/jpeg/">image/jpeg</a> package, compose them using
-<a href="/pkg/image/draw/">image/draw</a>, and then encode the result using
-<a href="/pkg/img/png">image/png</a>, then your code should still work as
-before.
-If your code <i>does</i> refer to <code>Pix</code> fields see the 
-<a href="/doc/devel/weekly.html#2011-07-19">weekly.2011-07-19</a>
-snapshot notes for how to update your code.
-</p>
-
-<p>
-<a href="/pkg/template/">Package template</a> has been replaced with a new
-templating package (formerly <code>exp/template</code>). The original template
-package is still available as <a href="/pkg/old/template/">old/template</a>.
-The <code>old/template</code> package is deprecated and will be removed.
-The Go tree has been updated to use the new template package. We encourage
-users of the old template package to switch to the new one. Code that uses
-<code>template</code> or <code>exp/template</code> will need to change its
-import lines to <code>"old/template"</code> or <code>"template"</code>,
-respectively.
-</p>
-
-<h3 id="r60.cmd">Tools</h3>
-
-<p>
-<a href="/cmd/goinstall/">Goinstall</a> now uses a new tag selection scheme.
-When downloading or updating, goinstall looks for a tag or branch with the
-<code>"go."</code> prefix that corresponds to the local Go version. For Go
-<code>release.r58</code> it looks for <code>go.r58</code>. For
-<code>weekly.2011-06-03</code> it looks for <code>go.weekly.2011-06-03</code>.
-If the specific <code>go.X</code> tag or branch is not found, it chooses the
-closest earlier version. If an appropriate tag or branch is found, goinstall
-uses that version of the code. Otherwise it uses the default version selected
-by the version control system. Library authors are encouraged to use the
-appropriate tag or branch names in their repositories to make their libraries
-more accessible.
-</p>
-
-<h3 id="r60.minor">Minor revisions</h3>
-
-<p>
-r60.1 includes a 
-<a href="//golang.org/change/1824581bf62d">linker
-fix</a>, a pair of
-<a href="//golang.org/change/9ef4429c2c64">goplay</a>
-<a href="//golang.org/change/d42ed8c3098e">fixes</a>,
-and a <code>json</code> package
-<a href="//golang.org/change/d5e97874fe84">fix</a> and
-a new
-<a href="//golang.org/change/4f0e6269213f">struct tag
-option</a>.
-</p>
-
-<p>
-r60.2
-<a href="//golang.org/change/ff19536042ac">fixes</a>
-a memory leak involving maps.
-</p>
-
-<p>
-r60.3 fixes a
-<a href="//golang.org/change/01fa62f5e4e5">reflect bug</a>.
-</p>
-
-<h2 id="r59">r59 (released 2011/08/01)</h2>
-
-<p>
-The r59 release corresponds to 
-<code><a href="weekly.html#2011-07-07">weekly.2011-07-07</a></code>.
-This section highlights the most significant changes in this release.
-For a more detailed summary, see the
-<a href="weekly.html#2011-07-07">weekly release notes</a>.
-For complete information, see the
-<a href="//code.google.com/p/go/source/list?r=release-branch.r59">Mercurial change list</a>.
-</p>
-
-<h3 id="r59.lang">Language</h3>
-
-<p>
-This release includes a language change that restricts the use of
-<code>goto</code>.  In essence, a <code>goto</code> statement outside a block
-cannot jump to a label inside that block. Your code may require changes if it
-uses <code>goto</code>.
-See <a href="//golang.org/change/dc6d3cf9279d">this
-changeset</a> for how the new rule affected the Go tree.
-</p>
-
-<h3 id="r59.pkg">Packages</h3>
-
-<p>
-As usual, <a href="/cmd/gofix/">gofix</a> will handle the bulk of the rewrites
-necessary for these changes to package APIs.
-</p>
-
-<p>
-<a href="/pkg/http">Package http</a> has a new
-<a href="/pkg/http/#FileSystem">FileSystem</a> interface that provides access
-to files. The <a href="/pkg/http/#FileServer">FileServer</a> helper now takes a
-<code>FileSystem</code> argument instead of an explicit file system root. By
-implementing your own <code>FileSystem</code> you can use the
-<code>FileServer</code> to serve arbitrary data.
-</p>
-
-<p>
-<a href="/pkg/os/">Package os</a>'s <code>ErrorString</code> type has been
-hidden. Most uses of <code>os.ErrorString</code> can be replaced with
-<a href="/pkg/os/#NewError">os.NewError</a>.
-</p>
-
-<p>
-<a href="/pkg/reflect/">Package reflect</a> supports a new struct tag scheme
-that enables sharing of struct tags between multiple packages.
-In this scheme, the tags must be of the form:
-</p>
-<pre>
-	`key:"value" key2:"value2"`
-</pre>
-<p>
-The <a href="/pkg/reflect/#StructField">StructField</a> type's Tag field now
-has type <a href="/pkg/reflect/#StructTag">StructTag</a>, which has a
-<code>Get</code> method. Clients of <a href="/pkg/json">json</a> and
-<a href="/pkg/xml">xml</a> will need to be updated. Code that says
-</p>
-<pre>
-	type T struct {
-		X int "name"
-	}
-</pre>
-<p>
-should become
-</p>
-<pre>
-	type T struct {
-		X int `json:"name"`  // or `xml:"name"`
-	}
-</pre>
-<p>
-Use <a href="/cmd/govet/">govet</a> to identify struct tags that need to be
-changed to use the new syntax.
-</p>
-
-<p>
-<a href="/pkg/sort/">Package sort</a>'s <code>IntArray</code> type has been
-renamed to <a href="/pkg/sort/#IntSlice">IntSlice</a>, and similarly for
-<a href="/pkg/sort/#Float64Slice">Float64Slice</a> and
-<a href="/pkg/sort/#StringSlice">StringSlice</a>.
-</p>
-
-<p>
-<a href="/pkg/strings/">Package strings</a>'s <code>Split</code> function has
-itself been split into <a href="/pkg/strings/#Split">Split</a> and
-<a href="/pkg/strings/#SplitN">SplitN</a>.
-<code>SplitN</code> is the same as the old <code>Split</code>.
-The new <code>Split</code> is equivalent to <code>SplitN</code> with a final
-argument of -1.
-</p>
-
-<a href="/pkg/image/draw/">Package image/draw</a>'s
-<a href="/pkg/image/draw/#Draw">Draw</a> function now takes an additional
-argument, a compositing operator.
-If in doubt, use <a href="/pkg/image/draw/#Op">draw.Over</a>.
-</p>
-
-<h3 id="r59.cmd">Tools</h3>
-
-<p>
-<a href="/cmd/goinstall/">Goinstall</a> now installs packages and commands from
-arbitrary remote repositories (not just Google Code, Github, and so on).
-See the <a href="/cmd/goinstall/">goinstall documentation</a> for details.
-</p>
-
-<h2 id="r58">r58 (released 2011/06/29)</h2>
-
-<p>
-The r58 release corresponds to 
-<code><a href="weekly.html#2011-06-09">weekly.2011-06-09</a></code>
-with additional bug fixes.
-This section highlights the most significant changes in this release.
-For a more detailed summary, see the
-<a href="weekly.html#2011-06-09">weekly release notes</a>.
-For complete information, see the
-<a href="//code.google.com/p/go/source/list?r=release-branch.r58">Mercurial change list</a>.
-</p>
-
-<h3 id="r58.lang">Language</h3>
-
-<p>
-This release fixes a <a href="//golang.org/change/b720749486e1">use of uninitialized memory in programs that misuse <code>goto</code></a>.
-</p>
-
-<h3 id="r58.pkg">Packages</h3>
-
-<p>
-As usual, <a href="/cmd/gofix/">gofix</a> will handle the bulk of the rewrites
-necessary for these changes to package APIs.
-</p>
-
-<p>
-<a href="/pkg/http/">Package http</a> drops the <code>finalURL</code> return
-value from the <a href="/pkg/http/#Client.Get">Client.Get</a> method. The value
-is now available via the new <code>Request</code> field on <a
-href="/pkg/http/#Response">http.Response</a>.
-Most instances of the type map[string][]string in have been
-replaced with the new <a href="/pkg/http/#Values">Values</a> type.
-</p>
-
-<p>
-<a href="/pkg/exec/">Package exec</a> has been redesigned with a more
-convenient and succinct API.
-</p>
-
-<p>
-<a href="/pkg/strconv/">Package strconv</a>'s <a href="/pkg/strconv/#Quote">Quote</a>
-function now escapes only those Unicode code points not classified as printable
-by <a href="/pkg/unicode/#IsPrint">unicode.IsPrint</a>.
-Previously Quote would escape all non-ASCII characters.
-This also affects the <a href="/pkg/fmt/">fmt</a> package's <code>"%q"</code>
-formatting directive. The previous quoting behavior is still available via
-strconv's new <a href="/pkg/strconv/#QuoteToASCII">QuoteToASCII</a> function.   
-</p>
-
-<p>
-<a href="/pkg/os/signal/">Package os/signal</a>'s
-<a href="/pkg/os/#Signal">Signal</a> and 
-<a href="/pkg/os/#UnixSignal">UnixSignal</a> types have been moved to the
-<a href="/pkg/os/">os</a> package.
-</p>
-
-<p>
-<a href="/pkg/image/draw/">Package image/draw</a> is the new name for
-<code>exp/draw</code>. The GUI-related code from <code>exp/draw</code> is now
-located in the <a href="/pkg/exp/gui/">exp/gui</a> package.
-</p>
-
-<h3 id="r58.cmd">Tools</h3>
-
-<p>
-<a href="/cmd/goinstall/">Goinstall</a> now observes the GOPATH environment
-variable to build and install your own code and external libraries outside of
-the Go tree (and avoid writing Makefiles).
-</p>
-
-
-<h3 id="r58.minor">Minor revisions</h3>
-
-<p>r58.1 adds 
-<a href="//golang.org/change/293c25943586">build</a> and
-<a href="//golang.org/change/bf17e96b6582">runtime</a>
-changes to make Go run on OS X 10.7 Lion.
-</p>
-
-<h2 id="r57">r57 (released 2011/05/03)</h2>
-
-<p>
-The r57 release corresponds to 
-<code><a href="weekly.html#2011-04-27">weekly.2011-04-27</a></code>
-with additional bug fixes.
-This section highlights the most significant changes in this release.
-For a more detailed summary, see the
-<a href="weekly.html#2011-04-27">weekly release notes</a>.
-For complete information, see the
-<a href="//code.google.com/p/go/source/list?r=release-branch.r57">Mercurial change list</a>.
-</p>
-
-<p>The new <a href="/cmd/gofix">gofix</a> tool finds Go programs that use old APIs and rewrites them to use
-newer ones.  After you update to a new Go release, gofix helps make the
-necessary changes to your programs. Gofix will handle the http, os, and syscall
-package changes described below, and we will update the program to keep up with
-future changes to the libraries. 
-Gofix can’t
-handle all situations perfectly, so read and test the changes it makes before
-committing them.
-See <a href="//blog.golang.org/2011/04/introducing-gofix.html">the gofix blog post</a> for more
-information.</p>
-
-<h3 id="r57.lang">Language</h3>
-
-<p>
-<a href="/doc/go_spec.html#Receive_operator">Multiple assignment syntax</a> replaces the <code>closed</code> function.
-The syntax for channel
-receives allows an optional second assigned value, a boolean value
-indicating whether the channel is closed. This code:
-</p>
-
-<pre>
-	v := &lt;-ch
-	if closed(ch) {
-		// channel is closed
-	}
-</pre>
-
-<p>should now be written as:</p>
-
-<pre>
-	v, ok := &lt;-ch
-	if !ok {
-		// channel is closed
-	}
-</pre>
-
-<p><a href="/doc/go_spec.html#Label_scopes">Unused labels are now illegal</a>, just as unused local variables are.</p>
-
-<h3 id="r57.pkg">Packages</h3>
-
-<p>
-<a href="/pkg/gob/">Package gob</a> will now encode and decode values of types that implement the
-<a href="/pkg/gob/#GobEncoder">GobEncoder</a> and
-<a href="/pkg/gob/#GobDecoder">GobDecoder</a> interfaces. This allows types with unexported
-fields to transmit self-consistent descriptions; examples include 
-<a href="/pkg/big/#Int.GobDecode">big.Int</a> and <a href="/pkg/big/#Rat.GobDecode">big.Rat</a>.
-</p>
-
-<p>
-<a href="/pkg/http/">Package http</a> has been redesigned.
-For clients, there are new
-<a href="/pkg/http/#Client">Client</a> and <a href="/pkg/http/#Transport">Transport</a>
-abstractions that give more control over HTTP details such as headers sent
-and redirections followed.  These abstractions make it easy to implement
-custom clients that add functionality such as <a href="//code.google.com/p/goauth2/source/browse/oauth/oauth.go">OAuth2</a>.
-For servers, <a href="/pkg/http/#ResponseWriter">ResponseWriter</a>
-has dropped its non-essential methods.
-The Hijack and Flush methods are no longer required;
-code can test for them by checking whether a specific value implements
-<a href="/pkg/http/#Hijacker">Hijacker</a> or <a href="/pkg/http/#Flusher">Flusher</a>.
-The RemoteAddr and UsingTLS methods are replaced by <a href="/pkg/http/#Request">Request</a>'s
-RemoteAddr and TLS fields.
-The SetHeader method is replaced by a Header method;
-its result, of type <a href="/pkg/http/#Header">Header</a>,
-implements Set and other methods.
-</p>
-
-<p>
-<a href="/pkg/net/">Package net</a>
-drops the <code>laddr</code> argument from <a href="/pkg/net/#Conn.Dial">Dial</a>
-and drops the <code>cname</code> return value
-from <a href="/pkg/net/#LookupHost">LookupHost</a>.
-The implementation now uses <a href="/cmd/cgo/">cgo</a> to implement
-network name lookups using the C library getaddrinfo(3)
-function when possible.  This ensures that Go and C programs
-resolve names the same way and also avoids the OS X 
-application-level firewall.
-</p>
-
-<p>
-<a href="/pkg/os/">Package os</a>
-introduces simplified <a href="/pkg/os/#File.Open">Open</a>
-and <a href="/pkg/os/#File.Create">Create</a> functions.
-The original Open is now available as <a href="/pkg/os/#File.OpenFile">OpenFile</a>.
-The final three arguments to <a href="/pkg/os/#Process.StartProcess">StartProcess</a>
-have been replaced by a pointer to a <a href="/pkg/os/#ProcAttr">ProcAttr</a>.
-</p>
-
-<p>
-<a href="/pkg/reflect/">Package reflect</a> has been redesigned.
-<a href="/pkg/reflect/#Type">Type</a> is now an interface that implements
-all the possible type methods.
-Instead of a type switch on a Type <code>t</code>, switch on <code>t.Kind()</code>.
-<a href="/pkg/reflect/#Value">Value</a> is now a struct value that
-implements all the possible value methods.
-Instead of a type switch on a Value <code>v</code>, switch on <code>v.Kind()</code>.
-Typeof and NewValue are now called <a href="/pkg/reflect/#Type.TypeOf">TypeOf</a> and <a href="/pkg/reflect/#Value.ValueOf">ValueOf</a>
-To create a writable Value, use <code>New(t).Elem()</code> instead of <code>Zero(t)</code>.
-See <a href="//golang.org/change/843855f3c026">the change description</a>
-for the full details.
-The new API allows a more efficient implementation of Value
-that avoids many of the allocations required by the previous API.
-</p>
-
-<p>
-Remember that gofix will handle the bulk of the rewrites
-necessary for these changes to package APIs.
-</p>
-
-<h3 id="r57.cmd">Tools</h3>
-
-<p><a href="/cmd/gofix/">Gofix</a>, a new command, is described above.</p>
-
-<p>
-<a href="/cmd/gotest/">Gotest</a> is now a Go program instead of a shell script.
-The new <code>-test.short</code> flag in combination with package testing's Short function
-allows you to write tests that can be run in normal or &ldquo;short&rdquo; mode;
-all.bash runs tests in short mode to reduce installation time.
-The Makefiles know about the flag: use <code>make testshort</code>.
-</p>
-
-<p>
-The run-time support now implements CPU and memory profiling.
-Gotest's new 
-<a href="/cmd/gotest/"><code>-test.cpuprofile</code> and
-<code>-test.memprofile</code> flags</a> make it easy to
-profile tests.
-To add profiling to your web server, see the <a href="/pkg/http/pprof/">http/pprof</a>
-documentation.
-For other uses, see the <a href="/pkg/runtime/pprof/">runtime/pprof</a> documentation.
-</p>
-
-<h3 id="r57.minor">Minor revisions</h3>
-
-<p>r57.1 fixes a <a href="//golang.org/change/ff2bc62726e7145eb2ecc1e0f076998e4a8f86f0">nil pointer dereference in http.FormFile</a>.</p>
-<p>r57.2 fixes a <a href="//golang.org/change/063b0ff67d8277df03c956208abc068076818dae">use of uninitialized memory in programs that misuse <code>goto</code></a>.</p>
-
-<h2 id="r56">r56 (released 2011/03/16)</h2>
-
-<p>
-The r56 release was the first stable release and corresponds to
-<code><a href="weekly.html#2011-03-07">weekly.2011-03-07.1</a></code>.
-The numbering starts at 56 because before this release,
-what we now consider weekly snapshots were called releases.
-</p>
--- a/doc/devel/release.html
+++ b/doc/devel/release.html
@@ -3,212 +3,16 @@
 }-->

 <p>This page summarizes the changes between official stable releases of Go.
-The <a href="//golang.org/change">change log</a> has the full details.</p>
+The <a href="//code.google.com/p/go/source/list">Mercurial change log</a>
+has the full details.</p>

 <p>To update to a specific release, use:</p>

 <pre>
-git pull
-git checkout <i>release-branch</i>
+hg pull
+hg update <i>tag</i>
 </pre>

-<h2 id="policy">Release Policy</h2>
-
-<p>
-Each major Go release is supported until there are two newer major releases.
-For example, Go 1.8 is supported until Go 1.10 is released,
-and Go 1.9 is supported until Go 1.11 is released.
-We fix critical problems, including <a href="/security">critical security problems</a>,
-in supported releases as needed by issuing minor revisions
-(for example, Go 1.8.1, Go 1.8.2, and so on).
-</p>
-
-<h2 id="go1.8">go1.8 (released 2017/02/16)</h2>
-
-<p>
-Go 1.8 is a major release of Go.
-Read the <a href="/doc/go1.8">Go 1.8 Release Notes</a> for more information.
-</p>
-
-<h3 id="go1.8.minor">Minor revisions</h3>
-
-<p>
-go1.8.1 (released 2017/04/07) includes fixes to the compiler, linker, runtime,
-documentation, <code>go</code> command and the <code>crypto/tls</code>,
-<code>encoding/xml</code>, <code>image/png</code>, <code>net</code>,
-<code>net/http</code>, <code>reflect</code>, <code>text/template</code>,
-and <code>time</code> packages.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.1">Go
-1.8.1 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.8.2 (released 2017/05/23) includes a security fix to the
-<code>crypto/elliptic</code> package.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.2">Go
-1.8.2 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.8.3 (released 2017/05/24) includes fixes to the compiler, runtime,
-documentation, and the <code>database/sql</code> package.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.3">Go
-1.8.3 milestone</a> on our issue tracker for details.
-</p>
-
-<h2 id="go1.7">go1.7 (released 2016/08/15)</h2>
-
-<p>
-Go 1.7 is a major release of Go.
-Read the <a href="/doc/go1.7">Go 1.7 Release Notes</a> for more information.
-</p>
-
-<h3 id="go1.7.minor">Minor revisions</h3>
-
-<p>
-go1.7.1 (released 2016/09/07) includes fixes to the compiler, runtime,
-documentation, and the <code>compress/flate</code>, <code>hash/crc32</code>,
-<code>io</code>, <code>net</code>, <code>net/http</code>,
-<code>path/filepath</code>, <code>reflect</code>, and <code>syscall</code>
-packages.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.1">Go
-1.7.1 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.7.2 should not be used. It was tagged but not fully released.
-The release was deferred due to a last minute bug report.
-Use go1.7.3 instead, and refer to the summary of changes below.
-</p>
-
-<p>
-go1.7.3 (released 2016/10/19) includes fixes to the compiler, runtime,
-and the <code>crypto/cipher</code>, <code>crypto/tls</code>,
-<code>net/http</code>, and <code>strings</code> packages.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.3">Go
-1.7.3 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.7.4 (released 2016/12/01) includes two security fixes.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.4">Go
-1.7.4 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.7.5 (released 2017/01/26) includes fixes to the compiler, runtime,
-and the <code>crypto/x509</code> and <code>time</code> packages.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.5">Go
-1.7.5 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.7.6 (released 2017/05/23) includes the same security fix as Go 1.8.2 and
-was released at the same time.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.2">Go
-1.8.2 milestone</a> on our issue tracker for details.
-</p>
-
-<h2 id="go1.6">go1.6 (released 2016/02/17)</h2>
-
-<p>
-Go 1.6 is a major release of Go.
-Read the <a href="/doc/go1.6">Go 1.6 Release Notes</a> for more information.
-</p>
-
-<h3 id="go1.6.minor">Minor revisions</h3>
-
-<p>
-go1.6.1 (released 2016/04/12) includes two security fixes.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.1">Go
-1.6.1 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.6.2 (released 2016/04/20) includes fixes to the compiler, runtime, tools,
-documentation, and the <code>mime/multipart</code>, <code>net/http</code>, and
-<code>sort</code> packages.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.2">Go
-1.6.2 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.6.3 (released 2016/07/17) includes security fixes to the
-<code>net/http/cgi</code> package and <code>net/http</code> package when used in
-a CGI environment.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.3">Go
-1.6.3 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.6.4 (released 2016/12/01) includes two security fixes.
-It contains the same fixes as Go 1.7.4 and was released at the same time.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.4">Go
-1.7.4 milestone</a> on our issue tracker for details.
-</p>
-
-<h2 id="go1.5">go1.5 (released 2015/08/19)</h2>
-
-<p>
-Go 1.5 is a major release of Go.
-Read the <a href="/doc/go1.5">Go 1.5 Release Notes</a> for more information.
-</p>
-
-<h3 id="go1.5.minor">Minor revisions</h3>
-
-<p>
-go1.5.1 (released 2015/09/08) includes bug fixes to the compiler, assembler, and
-the <code>fmt</code>, <code>net/textproto</code>, <code>net/http</code>, and
-<code>runtime</code> packages.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.5.1">Go
-1.5.1 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.5.2 (released 2015/12/02) includes bug fixes to the compiler, linker, and
-the <code>mime/multipart</code>, <code>net</code>, and <code>runtime</code>
-packages.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.5.2">Go
-1.5.2 milestone</a> on our issue tracker for details.
-</p>
-
-<p>
-go1.5.3 (released 2016/01/13) includes a security fix to the <code>math/big</code> package
-affecting the <code>crypto/tls</code> package.
-See the <a href="https://golang.org/s/go153announce">release announcement</a> for details.
-</p>
-
-<p>
-go1.5.4 (released 2016/04/12) includes two security fixes.
-It contains the same fixes as Go 1.6.1 and was released at the same time.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.1">Go
-1.6.1 milestone</a> on our issue tracker for details.
-</p>
-
-<h2 id="go1.4">go1.4 (released 2014/12/10)</h2>
-
-<p>
-Go 1.4 is a major release of Go.
-Read the <a href="/doc/go1.4">Go 1.4 Release Notes</a> for more information.
-</p>
-
-<h3 id="go1.4.minor">Minor revisions</h3>
-
-<p>
-go1.4.1 (released 2015/01/15) includes bug fixes to the linker and the <code>log</code>, <code>syscall</code>, and <code>runtime</code> packages.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.4.1">Go 1.4.1 milestone on our issue tracker</a> for details.
-</p>
-
-<p>
-go1.4.2 (released 2015/02/17) includes bug fixes to the <code>go</code> command, the compiler and linker, and the <code>runtime</code>, <code>syscall</code>, <code>reflect</code>, and <code>math/big</code> packages.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.4.2">Go 1.4.2 milestone on our issue tracker</a> for details.
-</p>
-
-<p>
-go1.4.3 (released 2015/09/22) includes security fixes to the <code>net/http</code> package and bug fixes to the <code>runtime</code> package.
-See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.4.3">Go 1.4.3 milestone on our issue tracker</a> for details.
-</p>
-
 <h2 id="go1.3">go1.3 (released 2014/06/18)</h2>

 <p>
@@ -220,17 +24,17 @@ Read the <a href="/doc/go1.3">Go 1.3 Release Notes</a> for more information.

 <p>
 go1.3.1 (released 2014/08/13) includes bug fixes to the compiler and the <code>runtime</code>, <code>net</code>, and <code>crypto/rsa</code> packages.
-See the <a href="https://github.com/golang/go/commits/go1.3.1">change history</a> for details.
+See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.3&r=073fc578434bf3e1e22749b559d273c8da728ebb">change history</a> for details.
 </p>

 <p>
 go1.3.2 (released 2014/09/25) includes bug fixes to cgo and the crypto/tls packages.
-See the <a href="https://github.com/golang/go/commits/go1.3.2">change history</a> for details.
+See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.3&r=go1.3.2">change history</a> for details.
 </p>

 <p>
 go1.3.3 (released 2014/09/30) includes further bug fixes to cgo, the runtime package, and the nacl port. 
-See the <a href="https://github.com/golang/go/commits/go1.3.3">change history</a> for details.
+See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.3&r=go1.3.3">change history</a> for details.
 </p>

 <h2 id="go1.2">go1.2 (released 2013/12/01)</h2>
@@ -244,12 +48,12 @@ Read the <a href="/doc/go1.2">Go 1.2 Release Notes</a> for more information.

 <p>
 go1.2.1 (released 2014/03/02) includes bug fixes to the <code>runtime</code>, <code>net</code>, and <code>database/sql</code> packages.
-See the <a href="https://github.com/golang/go/commits/go1.2.1">change history</a> for details.
+See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.2&r=7ada9e760ce34e78aee5b476c9621556d0fa5d31">change history</a> for details.
 </p>

 <p>
 go1.2.2 (released 2014/05/05) includes a
-<a href="https://github.com/golang/go/commits/go1.2.2">security fix</a>
+<a href="//code.google.com/p/go/source/detail?r=bda3619e7a2c&repo=tools">security fix</a>
 that affects the tour binary included in the binary distributions (thanks to Guillaume T).
 </p>

@@ -264,17 +68,17 @@ Read the <a href="/doc/go1.1">Go 1.1 Release Notes</a> for more information.

 <p>
 go1.1.1 (released 2013/06/13) includes several compiler and runtime bug fixes.
-See the <a href="https://github.com/golang/go/commits/go1.1.1">change history</a> for details.
+See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.1&r=43c4a41d24382a56a90e924800c681e435d9e399">change history</a> for details.
 </p>

 <p>
 go1.1.2 (released 2013/08/13) includes fixes to the <code>gc</code> compiler
 and <code>cgo</code>, and the <code>bufio</code>, <code>runtime</code>,
 <code>syscall</code>, and <code>time</code> packages.
-See the <a href="https://github.com/golang/go/commits/go1.1.2">change history</a> for details.
+See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1.1&r=a6a9792f94acd4ff686b2bc57383d163608b91cf">change history</a> for details.
 If you use package syscall's <code>Getrlimit</code> and <code>Setrlimit</code>
 functions under Linux on the ARM or 386 architectures, please note change
-<a href="//golang.org/cl/11803043">11803043</a>
+<a href="//golang.org/change/55ac276af5a7">55ac276af5a7</a>
 that fixes <a href="//golang.org/issue/5949">issue 5949</a>.
 </p>

@@ -301,7 +105,7 @@ The go1 release corresponds to

 <p>
 go1.0.1 (released 2012/04/25) was issued to
-<a href="//golang.org/cl/6061043">fix</a> an
+<a href="//golang.org/change/a890477d3dfb">fix</a> an
 <a href="//golang.org/issue/3545">escape analysis bug</a>
 that can lead to memory corruption.
 It also includes several minor code and documentation fixes.
@@ -320,13 +124,452 @@ go1.0.3 (released 2012/09/21) includes minor code and documentation fixes.
 </p>

 <p>
-See the <a href="https://github.com/golang/go/commits/release-branch.go1">go1 release branch history</a> for the complete list of changes.
+See the <a href="//code.google.com/p/go/source/list?name=release-branch.go1">go1 release branch history</a> for the complete list of changes.
 </p>

-<h2 id="pre.go1">Older releases</h2>
+<h2 id="r60">r60 (released 2011/09/07)</h2>

 <p>
-See the <a href="pre_go1.html">Pre-Go 1 Release History</a> page for notes
-on earlier releases.
+The r60 release corresponds to 
+<code><a href="weekly.html#2011-08-17">weekly.2011-08-17</a></code>.
+This section highlights the most significant changes in this release.
+For a more detailed summary, see the
+<a href="weekly.html#2011-08-17">weekly release notes</a>.
+For complete information, see the
+<a href="//code.google.com/p/go/source/list?r=release-branch.r60">Mercurial change list</a>.
 </p>

+<h3 id="r60.lang">Language</h3>
+
+<p>
+An "else" block is now required to have braces except if the body of the "else"
+is another "if". Since gofmt always puts those braces in anyway,
+gofmt-formatted programs will not be affected.
+To fix other programs, run gofmt.
+</p>
+
+<h3 id="r60.pkg">Packages</h3>
+
+<p>
+<a href="/pkg/http/">Package http</a>'s URL parsing and query escaping code
+(such as <code>ParseURL</code> and <code>URLEscape</code>) has been moved to
+the new <a href="/pkg/url/">url package</a>, with several simplifications to
+the names. Client code can be updated automatically with gofix.
+</p>
+
+<p>
+<a href="/pkg/image/">Package image</a> has had significant changes made to the
+<code>Pix</code> field of struct types such as
+<a href="/pkg/image/#RGBA">image.RGBA</a> and
+<a href="/pkg/image/#NRGBA">image.NRGBA</a>.
+The <a href="/pkg/image/#Image">image.Image</a> interface type has not changed,
+though, and you should not need to change your code if you don't explicitly
+refer to <code>Pix</code> fields. For example, if you decode a number of images
+using the <a href="/pkg/image/jpeg/">image/jpeg</a> package, compose them using
+<a href="/pkg/image/draw/">image/draw</a>, and then encode the result using
+<a href="/pkg/img/png">image/png</a>, then your code should still work as
+before.
+If your code <i>does</i> refer to <code>Pix</code> fields see the 
+<a href="/doc/devel/weekly.html#2011-07-19">weekly.2011-07-19</a>
+snapshot notes for how to update your code.
+</p>
+
+<p>
+<a href="/pkg/template/">Package template</a> has been replaced with a new
+templating package (formerly <code>exp/template</code>). The original template
+package is still available as <a href="/pkg/old/template/">old/template</a>.
+The <code>old/template</code> package is deprecated and will be removed.
+The Go tree has been updated to use the new template package. We encourage
+users of the old template package to switch to the new one. Code that uses
+<code>template</code> or <code>exp/template</code> will need to change its
+import lines to <code>"old/template"</code> or <code>"template"</code>,
+respectively.
+</p>
+
+<h3 id="r60.cmd">Tools</h3>
+
+<p>
+<a href="/cmd/goinstall/">Goinstall</a> now uses a new tag selection scheme.
+When downloading or updating, goinstall looks for a tag or branch with the
+<code>"go."</code> prefix that corresponds to the local Go version. For Go
+<code>release.r58</code> it looks for <code>go.r58</code>. For
+<code>weekly.2011-06-03</code> it looks for <code>go.weekly.2011-06-03</code>.
+If the specific <code>go.X</code> tag or branch is not found, it chooses the
+closest earlier version. If an appropriate tag or branch is found, goinstall
+uses that version of the code. Otherwise it uses the default version selected
+by the version control system. Library authors are encouraged to use the
+appropriate tag or branch names in their repositories to make their libraries
+more accessible.
+</p>
+
+<h3 id="r60.minor">Minor revisions</h3>
+
+<p>
+r60.1 includes a 
+<a href="//golang.org/change/1824581bf62d">linker
+fix</a>, a pair of
+<a href="//golang.org/change/9ef4429c2c64">goplay</a>
+<a href="//golang.org/change/d42ed8c3098e">fixes</a>,
+and a <code>json</code> package
+<a href="//golang.org/change/d5e97874fe84">fix</a> and
+a new
+<a href="//golang.org/change/4f0e6269213f">struct tag
+option</a>.
+</p>
+
+<p>
+r60.2
+<a href="//golang.org/change/ff19536042ac">fixes</a>
+a memory leak involving maps.
+</p>
+
+<p>
+r60.3 fixes a
+<a href="//golang.org/change/01fa62f5e4e5">reflect bug</a>.
+</p>
+
+<h2 id="r59">r59 (released 2011/08/01)</h2>
+
+<p>
+The r59 release corresponds to 
+<code><a href="weekly.html#2011-07-07">weekly.2011-07-07</a></code>.
+This section highlights the most significant changes in this release.
+For a more detailed summary, see the
+<a href="weekly.html#2011-07-07">weekly release notes</a>.
+For complete information, see the
+<a href="//code.google.com/p/go/source/list?r=release-branch.r59">Mercurial change list</a>.
+</p>
+
+<h3 id="r59.lang">Language</h3>
+
+<p>
+This release includes a language change that restricts the use of
+<code>goto</code>.  In essence, a <code>goto</code> statement outside a block
+cannot jump to a label inside that block. Your code may require changes if it
+uses <code>goto</code>.
+See <a href="//golang.org/change/dc6d3cf9279d">this
+changeset</a> for how the new rule affected the Go tree.
+</p>
+
+<h3 id="r59.pkg">Packages</h3>
+
+<p>
+As usual, <a href="/cmd/gofix/">gofix</a> will handle the bulk of the rewrites
+necessary for these changes to package APIs.
+</p>
+
+<p>
+<a href="/pkg/http">Package http</a> has a new
+<a href="/pkg/http/#FileSystem">FileSystem</a> interface that provides access
+to files. The <a href="/pkg/http/#FileServer">FileServer</a> helper now takes a
+<code>FileSystem</code> argument instead of an explicit file system root. By
+implementing your own <code>FileSystem</code> you can use the
+<code>FileServer</code> to serve arbitrary data.
+</p>
+
+<p>
+<a href="/pkg/os/">Package os</a>'s <code>ErrorString</code> type has been
+hidden. Most uses of <code>os.ErrorString</code> can be replaced with
+<a href="/pkg/os/#NewError">os.NewError</a>.
+</p>
+
+<p>
+<a href="/pkg/reflect/">Package reflect</a> supports a new struct tag scheme
+that enables sharing of struct tags between multiple packages.
+In this scheme, the tags must be of the form:
+</p>
+<pre>
+	`key:"value" key2:"value2"`
+</pre>
+<p>
+The <a href="/pkg/reflect/#StructField">StructField</a> type's Tag field now
+has type <a href="/pkg/reflect/#StructTag">StructTag</a>, which has a
+<code>Get</code> method. Clients of <a href="/pkg/json">json</a> and
+<a href="/pkg/xml">xml</a> will need to be updated. Code that says
+</p>
+<pre>
+	type T struct {
+		X int "name"
+	}
+</pre>
+<p>
+should become
+</p>
+<pre>
+	type T struct {
+		X int `json:"name"`  // or `xml:"name"`
+	}
+</pre>
+<p>
+Use <a href="/cmd/govet/">govet</a> to identify struct tags that need to be
+changed to use the new syntax.
+</p>
+
+<p>
+<a href="/pkg/sort/">Package sort</a>'s <code>IntArray</code> type has been
+renamed to <a href="/pkg/sort/#IntSlice">IntSlice</a>, and similarly for
+<a href="/pkg/sort/#Float64Slice">Float64Slice</a> and
+<a href="/pkg/sort/#StringSlice">StringSlice</a>.
+</p>
+
+<p>
+<a href="/pkg/strings/">Package strings</a>'s <code>Split</code> function has
+itself been split into <a href="/pkg/strings/#Split">Split</a> and
+<a href="/pkg/strings/#SplitN">SplitN</a>.
+<code>SplitN</code> is the same as the old <code>Split</code>.
+The new <code>Split</code> is equivalent to <code>SplitN</code> with a final
+argument of -1.
+</p>
+
+<a href="/pkg/image/draw/">Package image/draw</a>'s
+<a href="/pkg/image/draw/#Draw">Draw</a> function now takes an additional
+argument, a compositing operator.
+If in doubt, use <a href="/pkg/image/draw/#Op">draw.Over</a>.
+</p>
+
+<h3 id="r59.cmd">Tools</h3>
+
+<p>
+<a href="/cmd/goinstall/">Goinstall</a> now installs packages and commands from
+arbitrary remote repositories (not just Google Code, Github, and so on).
+See the <a href="/cmd/goinstall/">goinstall documentation</a> for details.
+</p>
+
+<h2 id="r58">r58 (released 2011/06/29)</h2>
+
+<p>
+The r58 release corresponds to 
+<code><a href="weekly.html#2011-06-09">weekly.2011-06-09</a></code>
+with additional bug fixes.
+This section highlights the most significant changes in this release.
+For a more detailed summary, see the
+<a href="weekly.html#2011-06-09">weekly release notes</a>.
+For complete information, see the
+<a href="//code.google.com/p/go/source/list?r=release-branch.r58">Mercurial change list</a>.
+</p>
+
+<h3 id="r58.lang">Language</h3>
+
+<p>
+This release fixes a <a href="//golang.org/change/b720749486e1">use of uninitialized memory in programs that misuse <code>goto</code></a>.
+</p>
+
+<h3 id="r58.pkg">Packages</h3>
+
+<p>
+As usual, <a href="/cmd/gofix/">gofix</a> will handle the bulk of the rewrites
+necessary for these changes to package APIs.
+</p>
+
+<p>
+<a href="/pkg/http/">Package http</a> drops the <code>finalURL</code> return
+value from the <a href="/pkg/http/#Client.Get">Client.Get</a> method. The value
+is now available via the new <code>Request</code> field on <a
+href="/pkg/http/#Response">http.Response</a>.
+Most instances of the type map[string][]string in have been
+replaced with the new <a href="/pkg/http/#Values">Values</a> type.
+</p>
+
+<p>
+<a href="/pkg/exec/">Package exec</a> has been redesigned with a more
+convenient and succinct API.
+</p>
+
+<p>
+<a href="/pkg/strconv/">Package strconv</a>'s <a href="/pkg/strconv/#Quote">Quote</a>
+function now escapes only those Unicode code points not classified as printable
+by <a href="/pkg/unicode/#IsPrint">unicode.IsPrint</a>.
+Previously Quote would escape all non-ASCII characters.
+This also affects the <a href="/pkg/fmt/">fmt</a> package's <code>"%q"</code>
+formatting directive. The previous quoting behavior is still available via
+strconv's new <a href="/pkg/strconv/#QuoteToASCII">QuoteToASCII</a> function.   
+</p>
+
+<p>
+<a href="/pkg/os/signal/">Package os/signal</a>'s
+<a href="/pkg/os/#Signal">Signal</a> and 
+<a href="/pkg/os/#UnixSignal">UnixSignal</a> types have been moved to the
+<a href="/pkg/os/">os</a> package.
+</p>
+
+<p>
+<a href="/pkg/image/draw/">Package image/draw</a> is the new name for
+<code>exp/draw</code>. The GUI-related code from <code>exp/draw</code> is now
+located in the <a href="/pkg/exp/gui/">exp/gui</a> package.
+</p>
+
+<h3 id="r58.cmd">Tools</h3>
+
+<p>
+<a href="/cmd/goinstall/">Goinstall</a> now observes the GOPATH environment
+variable to build and install your own code and external libraries outside of
+the Go tree (and avoid writing Makefiles).
+</p>
+
+
+<h3 id="r58.minor">Minor revisions</h3>
+
+<p>r58.1 adds 
+<a href="//golang.org/change/293c25943586">build</a> and
+<a href="//golang.org/change/bf17e96b6582">runtime</a>
+changes to make Go run on OS X 10.7 Lion.
+</p>
+
+<h2 id="r57">r57 (released 2011/05/03)</h2>
+
+<p>
+The r57 release corresponds to 
+<code><a href="weekly.html#2011-04-27">weekly.2011-04-27</a></code>
+with additional bug fixes.
+This section highlights the most significant changes in this release.
+For a more detailed summary, see the
+<a href="weekly.html#2011-04-27">weekly release notes</a>.
+For complete information, see the
+<a href="//code.google.com/p/go/source/list?r=release-branch.r57">Mercurial change list</a>.
+</p>
+
+<p>The new <a href="/cmd/gofix">gofix</a> tool finds Go programs that use old APIs and rewrites them to use
+newer ones.  After you update to a new Go release, gofix helps make the
+necessary changes to your programs. Gofix will handle the http, os, and syscall
+package changes described below, and we will update the program to keep up with
+future changes to the libraries. 
+Gofix can’t
+handle all situations perfectly, so read and test the changes it makes before
+committing them.
+See <a href="//blog.golang.org/2011/04/introducing-gofix.html">the gofix blog post</a> for more
+information.</p>
+
+<h3 id="r57.lang">Language</h3>
+
+<p>
+<a href="/doc/go_spec.html#Receive_operator">Multiple assignment syntax</a> replaces the <code>closed</code> function.
+The syntax for channel
+receives allows an optional second assigned value, a boolean value
+indicating whether the channel is closed. This code:
+</p>
+
+<pre>
+	v := &lt;-ch
+	if closed(ch) {
+		// channel is closed
+	}
+</pre>
+
+<p>should now be written as:</p>
+
+<pre>
+	v, ok := &lt;-ch
+	if !ok {
+		// channel is closed
+	}
+</pre>
+
+<p><a href="/doc/go_spec.html#Label_scopes">Unused labels are now illegal</a>, just as unused local variables are.</p>
+
+<h3 id="r57.pkg">Packages</h3>
+
+<p>
+<a href="/pkg/gob/">Package gob</a> will now encode and decode values of types that implement the
+<a href="/pkg/gob/#GobEncoder">GobEncoder</a> and
+<a href="/pkg/gob/#GobDecoder">GobDecoder</a> interfaces. This allows types with unexported
+fields to transmit self-consistent descriptions; examples include 
+<a href="/pkg/big/#Int.GobDecode">big.Int</a> and <a href="/pkg/big/#Rat.GobDecode">big.Rat</a>.
+</p>
+
+<p>
+<a href="/pkg/http/">Package http</a> has been redesigned.
+For clients, there are new
+<a href="/pkg/http/#Client">Client</a> and <a href="/pkg/http/#Transport">Transport</a>
+abstractions that give more control over HTTP details such as headers sent
+and redirections followed.  These abstractions make it easy to implement
+custom clients that add functionality such as <a href="//code.google.com/p/goauth2/source/browse/oauth/oauth.go">OAuth2</a>.
+For servers, <a href="/pkg/http/#ResponseWriter">ResponseWriter</a>
+has dropped its non-essential methods.
+The Hijack and Flush methods are no longer required;
+code can test for them by checking whether a specific value implements
+<a href="/pkg/http/#Hijacker">Hijacker</a> or <a href="/pkg/http/#Flusher">Flusher</a>.
+The RemoteAddr and UsingTLS methods are replaced by <a href="/pkg/http/#Request">Request</a>'s
+RemoteAddr and TLS fields.
+The SetHeader method is replaced by a Header method;
+its result, of type <a href="/pkg/http/#Header">Header</a>,
+implements Set and other methods.
+</p>
+
+<p>
+<a href="/pkg/net/">Package net</a>
+drops the <code>laddr</code> argument from <a href="/pkg/net/#Conn.Dial">Dial</a>
+and drops the <code>cname</code> return value
+from <a href="/pkg/net/#LookupHost">LookupHost</a>.
+The implementation now uses <a href="/cmd/cgo/">cgo</a> to implement
+network name lookups using the C library getaddrinfo(3)
+function when possible.  This ensures that Go and C programs
+resolve names the same way and also avoids the OS X 
+application-level firewall.
+</p>
+
+<p>
+<a href="/pkg/os/">Package os</a>
+introduces simplified <a href="/pkg/os/#File.Open">Open</a>
+and <a href="/pkg/os/#File.Create">Create</a> functions.
+The original Open is now available as <a href="/pkg/os/#File.OpenFile">OpenFile</a>.
+The final three arguments to <a href="/pkg/os/#Process.StartProcess">StartProcess</a>
+have been replaced by a pointer to a <a href="/pkg/os/#ProcAttr">ProcAttr</a>.
+</p>
+
+<p>
+<a href="/pkg/reflect/">Package reflect</a> has been redesigned.
+<a href="/pkg/reflect/#Type">Type</a> is now an interface that implements
+all the possible type methods.
+Instead of a type switch on a Type <code>t</code>, switch on <code>t.Kind()</code>.
+<a href="/pkg/reflect/#Value">Value</a> is now a struct value that
+implements all the possible value methods.
+Instead of a type switch on a Value <code>v</code>, switch on <code>v.Kind()</code>.
+Typeof and NewValue are now called <a href="/pkg/reflect/#Type.TypeOf">TypeOf</a> and <a href="/pkg/reflect/#Value.ValueOf">ValueOf</a>
+To create a writable Value, use <code>New(t).Elem()</code> instead of <code>Zero(t)</code>.
+See <a href="//golang.org/change/843855f3c026">the change description</a>
+for the full details.
+The new API allows a more efficient implementation of Value
+that avoids many of the allocations required by the previous API.
+</p>
+
+<p>
+Remember that gofix will handle the bulk of the rewrites
+necessary for these changes to package APIs.
+</p>
+
+<h3 id="r57.cmd">Tools</h3>
+
+<p><a href="/cmd/gofix/">Gofix</a>, a new command, is described above.</p>
+
+<p>
+<a href="/cmd/gotest/">Gotest</a> is now a Go program instead of a shell script.
+The new <code>-test.short</code> flag in combination with package testing's Short function
+allows you to write tests that can be run in normal or &ldquo;short&rdquo; mode;
+all.bash runs tests in short mode to reduce installation time.
+The Makefiles know about the flag: use <code>make testshort</code>.
+</p>
+
+<p>
+The run-time support now implements CPU and memory profiling.
+Gotest's new 
+<a href="/cmd/gotest/"><code>-test.cpuprofile</code> and
+<code>-test.memprofile</code> flags</a> make it easy to
+profile tests.
+To add profiling to your web server, see the <a href="/pkg/http/pprof/">http/pprof</a>
+documentation.
+For other uses, see the <a href="/pkg/runtime/pprof/">runtime/pprof</a> documentation.
+</p>
+
+<h3 id="r57.minor">Minor revisions</h3>
+
+<p>r57.1 fixes a <a href="//golang.org/change/ff2bc62726e7145eb2ecc1e0f076998e4a8f86f0">nil pointer dereference in http.FormFile</a>.</p>
+<p>r57.2 fixes a <a href="//golang.org/change/063b0ff67d8277df03c956208abc068076818dae">use of uninitialized memory in programs that misuse <code>goto</code></a>.</p>
+
+<h2 id="r56">r56 (released 2011/03/16)</h2>
+
+<p>
+The r56 release was the first stable release and corresponds to
+<code><a href="weekly.html#2011-03-07">weekly.2011-03-07.1</a></code>.
+The numbering starts at 56 because before this release,
+what we now consider weekly snapshots were called releases.
+</p>
--- a/doc/devel/weekly.html
+++ b/doc/devel/weekly.html
@@ -5,7 +5,7 @@
 <p>This page summarizes the changes between tagged weekly snapshots of Go.
 Such snapshots are no longer created. This page remains as a historical reference only.</p>

-<p>For recent information, see the <a href="//golang.org/change">change log</a> and <a href="//groups.google.com/group/golang-dev/">development mailing list</a>.</p>
+<p>For recent information, see the <a href="//code.google.com/p/go/source/list">Mercurial change log</a> and <a href="//groups.google.com/group/golang-dev/">development mailing list</a>.</p>

 <h2 id="2012-03-27">2012-03-27 (<a href="release.html#go1">Go 1</a>)</h2>

@@ -519,7 +519,7 @@ Other changes:
 	fix FreeBSD signal handling around thread creation (thanks Devon H. O'Dell),
 	goroutine profile, stack dumps,
 	implement runtime.osyield on FreeBSD 386, amd64 (thanks Devon H. O'Dell),
-	permit default behavior of SIGTSTP, SIGTTIN, SIGTTOU,
+	permit default behaviour of SIGTSTP, SIGTTIN, SIGTTOU,
 	release unused memory to the OS (thanks Sébastien Paolacci),
 	remove an obsolete file (thanks Mikio Hara).
 * spec: make all comparison results untyped bool,
@@ -2450,7 +2450,7 @@ The http package's URL parsing and query escaping code (such as ParseURL and
 URLEscape) has been moved to the new url package, with several simplifications
 to the names. Client code can be updated automatically with gofix.

-* asn1: support unmarshaling structs with int32 members (thanks Dave Cheney).
+* asn1: support unmarshalling structs with int32 members (thanks Dave Cheney).
 * build: allow builds without cgo or hg,
 	support versioning without hg (thanks Gustavo Niemeyer).
 * builtin: add documentation for builtins.
@@ -3030,7 +3030,7 @@ Other changes:
 * 5g: alignment fixes.
 * 6l, 8l: fix Mach-O binaries with many dynamic libraries.
 * 8l: emit resources (.rsrc) in Windows PE.  (thanks Wei Guangjing).
-* asn1: fix marshaling of empty optional RawValues (thanks Mikkel Krautz).
+* asn1: fix marshalling of empty optional RawValues (thanks Mikkel Krautz).
 * big: make Int and Rat implement fmt.Scanner (thanks Evan Shaw),
 	~8x faster number scanning,
 	remove some unnecessary conversions.
@@ -4157,7 +4157,7 @@ Other changes in this release:
 * suffixarray: use binary search for both ends of Lookup (thanks Eric Eisner).
 * syscall: add missing network interface constants (thanks Mikio Hara).
 * template: treat map keys as zero, not non-existent (thanks Roger Peppe).
-* time: allow canceling of After events (thanks Roger Peppe),
+* time: allow cancelling of After events (thanks Roger Peppe),
        support Solaris zoneinfo directory.
 * token/position: added SetLinesForContent.
 * unicode: update to unicode 6.0.0.
@@ -4238,7 +4238,7 @@ example: http://golang.org/pkg/xml/
 <pre>
 The json, gob, and template packages have changed, and code that uses them
 may need to be updated after this release. They will no longer read or write
-unexported struct fields. When marshaling a struct with json or gob the
+unexported struct fields. When marshalling a struct with json or gob the
 unexported fields will be silently ignored. Attempting to unmarshal json or
 gob data into an unexported field will generate an error. Accessing an
 unexported field from a template will cause the Execute function to return
@@ -5682,7 +5682,7 @@ Other changes:
 	pidigits ~10% performance win by using adds instead of shifts.
 * time: remove incorrect time.ISO8601 and add time.RFC3339 (thanks Micah Stetson).
 * utf16: add DecodeRune, EncodeRune.
-* xml: add support for XML marshaling embedded structs (thanks Raif S. Naffah),
+* xml: add support for XML marshalling embedded structs (thanks Raif S. Naffah),
 	new "innerxml" tag to collect inner XML.
 </pre>

@@ -5696,7 +5696,7 @@ This release contains many changes:
 * cmath: new complex math library (thanks Charles L. Dorian).
 * docs: update to match current coding style (thanks Christopher Wedgwood).
 * exp/eval: fix example and add target to Makefile (thanks Evan Shaw).
-* fmt: change behavior of format verb %b to match %x when negative (thanks Andrei Vieru).
+* fmt: change behaviour of format verb %b to match %x when negative (thanks Andrei Vieru).
 * gc: compile s == "" as len(s) == 0,
 	distinguish fatal compiler bug from error+exit,
 	fix alignment on non-amd64,
@@ -5925,10 +5925,10 @@ Other changes and fixes:
 * 8a/8l: Added CMOVcc instructions (thanks Evan Shaw)
 * 8l: pe executable building code changed to include import table for kernel32.dll functions (thanks Alex Brainman)
 * 5g/6g/8g: bug fixes
-* asn1: bug fixes and additions (incl marshaling)
+* asn1: bug fixes and additions (incl marshalling)
 * build: fix build for Native Client, Linux/ARM
 * dashboard: show benchmarks, add garbage collector benchmarks
-* encoding/pem: add marshaling support
+* encoding/pem: add marshalling support
 * exp/draw: fast paths for a nil mask
 * godoc: support for directories outside $GOROOT
 * http: sort header keys when writing Response or Request to wire (thanks Petar Maymounkov)
@@ -5971,7 +5971,7 @@ You can now check build status on various platforms at the Go Dashboard:
 * runtime: add SetFinalizer
 * time: Sleep through interruptions (thanks Chris Wedgwood)
 	add RFC822 formats
-	experimental implementation of Ticker using two goroutines for all tickers
+	experimental implemenation of Ticker using two goroutines for all tickers
 * xml: allow underscores in XML element names (thanks Michael Hoisie)
 	allow any scalar type in xml.Unmarshal
 </pre>
--- a/doc/docs.html
+++ b/doc/docs.html
@@ -40,13 +40,7 @@ The first section covers basic syntax and data structures; the second discusses
 methods and interfaces; and the third introduces Go's concurrency primitives.
 Each section concludes with a few exercises so you can practice what you've
 learned. You can <a href="//tour.golang.org/">take the tour online</a> or
-install it locally with:
-</p>
-<p>
-<pre>
-$ go get golang.org/x/tour/gotour
-</pre>
-This will place the <code>gotour</code> binary in your workspace's <code>bin</code> directory.
+<a href="//code.google.com/p/go-tour/">install it locally</a>.
 </p>

 <h3 id="code"><a href="code.html">How to write Go code</a></h3>
@@ -57,12 +51,6 @@ explains how to use the <a href="/cmd/go/">go command</a> to fetch, build, and
 install packages, commands, and run tests.
 </p>

-<h3 id="editors"><a href="editors.html">Editor plugins and IDEs</a></h3>
-<p>
-A document that summarizes commonly used editor plugins and IDEs with
-Go support.
-</p>
-
 <h3 id="effective_go"><a href="effective_go.html">Effective Go</a></h3>
 <p>
 A document that gives tips for writing clear, idiomatic Go code.
--- a/doc/editors.html
+++ b/doc/editors.html
@@ -1,210 +0,0 @@
-<!--{
-	"Title": "Editor plugins and IDEs",
-	"Template": true
-}-->
-
-<h2 id="introduction">Introduction</h2>
-
-<p>
-  This document lists commonly used editor plugins and IDEs from the Go ecosystem
-  that make Go development more productive and seamless.
-  A comprehensive list of editor support and IDEs for Go development is available at
-  <a href="http://golang.org/wiki/IDEsAndTextEditorPlugins">the wiki</a>.
-</p>
-
-<h2 id="options">Options</h2>
-<p>
-The Go ecosystem provides a variety of editor plugins and IDEs to enhance your day-to-day
-editing, navigation, testing, and debugging experience.
-</p>
-
-<ul>
-<li><a href="https://github.com/fatih/vim-go">Vim Go</a>: a plugin for Vim to provide Go programming language support</li>
-<li><a href="https://marketplace.visualstudio.com/items?itemName=lukehoban.Go">Visual Studio Code Go</a>:
-an extension for Visual Studio Code to provide support for the Go programming language</li>
-<li><a href="https://www.jetbrains.com/go">Gogland</a>: Gogland is distributed either as a standalone IDE
-or as a plugin for the IntelliJ Platform IDEs</li>
-</ul>
-
-<p>
-Note that these are only a few top solutions; a more comphensive
-community-maintained list of
-<a href="https://github.com/golang/go/wiki/IDEsAndTextEditorPlugins">IDEs and text editor plugins</a>
-is available at the Wiki.
-</p>
-
-<p>
-Each development environment integrates a number of Go-specific tools.
-The following feature matrix lists and compares the most significant features.
-</p>
-
-<table class="features-matrix">
-  <tr>
-    <th></th>
-    <th><img title="Vim Go" src="/doc/editors/vimgo.png"><br>Vim Go</th>
-    <th><img title="Visual Studio Code" src="/doc/editors/vscodego.png"><br>Visual Studio Code Go</th>
-    <th><img title="Gogland" src="/doc/editors/gogland.png"><br>Gogland</th>
-  </tr>
-  <tr>
-    <td class="feature-row" colspan="4">Editing features</td>
-  </tr>
-  <tr>
-    <td>Build and run from the editor/IDE</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Autocompletion of identifers (variable, method, and function names)</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Autocompletion based on type</td>
-    <td class="no">No</td>
-    <td class="no">No</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Rename identifiers</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Auto format, build, vet, and lint on save</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes<sup>1</sup></td>
-  </tr>
-  <tr>
-    <td>Auto insert import paths and remove unused on save</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes<sup>2</sup></td>
-  </tr>
-  <tr>
-    <td>Auto generate JSON, XML tags for struct fields</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td class="feature-row" colspan="4">Navigation features</td>
-  </tr>
-  <tr>
-    <td>Display documentation inline, or open godoc in browser</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Switch between <code>*.go</code> and <code>*_test.go</code> file</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Jump to definition and referees</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Look up for interface implementations</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Search for callers and callees</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td class="feature-row" colspan="4">Testing and debugging features</td>
-  </tr>
-  <tr>
-    <td>Debugger support</td>
-    <td class="no">No</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Run a single test case, all tests from file, or all tests from a package</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Auto generate tests for packages, files and identifiers</td>
-    <td class="no">No</td>
-    <td class="yes">Yes</td>
-    <td class="no">No</td>
-  </tr>
-  <tr>
-    <td>Debug tests</td>
-    <td class="no">No</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr>
-    <td>Display test coverage</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-    <td class="yes">Yes</td>
-  </tr>
-  <tr class="download">
-    <td></td>
-    <td><a href="https://github.com/fatih/vim-go">Install<a/></td>
-    <td><a href="https://marketplace.visualstudio.com/items?itemName=lukehoban.Go">Install<a/></td>
-    <td><a href="https://www.jetbrains.com/go">Install<a/></td>
-  </tr>
-</table>
-
-<p>
-<sup>1</sup>: Possible when enabled via Settings &gt; Go &gt; On Save, <code>go</code> <code>vet</code> and <code>golint</code> are available via plugins. Also runs tests on save if configured.
-<br>
-<sup>2</sup>: Additionally, user input can disambiguate when two or more options are available.
-</p>
-
-</div>
-
-<style>
-.features-matrix {
-  min-width: 800px;
-  border-collapse: collapse;
-}
-.features-matrix th {
-  width: 60px;
-  text-align: center;
-  font-size: 14px;
-  color: #666;
-}
-.features-matrix th img {
-  width: 48px;
-}
-.features-matrix .yes {
-  text-align: center;
-}
-.features-matrix .no {
-  text-align: center;
-  background-color: #ffe9e9;
-}
-.features-matrix .download {
-  font-weight: bold;
-  text-align: center;
-}
-.features-matrix td {
-  padding: 11px 5px 11px 5px;
-  border-bottom: solid 1px #ebebeb;
-}
-.features-matrix .feature-row {
-  background-color: #ebebeb;
-  font-weight: bold;
-}
-</style>
-
-<!--TODO(jbd): Add the Atom comparison-->
--- a/doc/editors/gogland.png
+++ b/doc/editors/gogland.png
--- a/doc/editors/vimgo.png
+++ b/doc/editors/vimgo.png
--- a/doc/editors/vscodego.png
+++ b/doc/editors/vscodego.png
--- a/doc/effective_go.html
+++ b/doc/effective_go.html
@@ -239,21 +239,21 @@ starts with the name being declared.
 </p>

 <pre>
-// Compile parses a regular expression and returns, if successful,
-// a Regexp that can be used to match against text.
-func Compile(str string) (*Regexp, error) {
+// Compile parses a regular expression and returns, if successful, a Regexp
+// object that can be used to match against text.
+func Compile(str string) (regexp *Regexp, err error) {
 </pre>

 <p>
-If every doc comment begins with the name of the item it describes,
-the output of <code>godoc</code> can usefully be run through <code>grep</code>.
+If the name always begins the comment, the output of <code>godoc</code>
+can usefully be run through <code>grep</code>.
 Imagine you couldn't remember the name "Compile" but were looking for
 the parsing function for regular expressions, so you ran
 the command,
 </p>

 <pre>
-$ godoc regexp | grep -i parse
+$ godoc regexp | grep parse
 </pre>

 <p>
@@ -866,7 +866,7 @@ var t interface{}
 t = functionOfSomeType()
 switch t := t.(type) {
 default:
-    fmt.Printf("unexpected type %T\n", t)     // %T prints whatever type t has
+    fmt.Printf("unexpected type %T", t)       // %T prints whatever type t has
 case bool:
    fmt.Printf("boolean %t\n", t)             // t has type bool
 case int:
@@ -1382,7 +1382,7 @@ limit of how much data to read.  Here is the signature of the
 <code>os</code>:
 </p>
 <pre>
-func (f *File) Read(buf []byte) (n int, err error)
+func (file *File) Read(buf []byte) (n int, err error)
 </pre>
 <p>
 The method returns the number of bytes read and an error value, if
@@ -1421,7 +1421,7 @@ resulting slice is returned.  The function uses the fact that
 <code>nil</code> slice, and return 0.
 </p>
 <pre>
-func Append(slice, data []byte) []byte {
+func Append(slice, data[]byte) []byte {
    l := len(slice)
    if l + len(data) &gt; cap(slice) {  // reallocate
        // Allocate double what's needed, for future growth.
@@ -1580,7 +1580,7 @@ if attended[person] { // will be false if person is not in the map
 <p>
 Sometimes you need to distinguish a missing entry from
 a zero value.  Is there an entry for <code>"UTC"</code>
-or is that 0 because it's not in the map at all?
+or is that the empty string because it's not in the map at all?
 You can discriminate with a form of multiple assignment.
 </p>
 <pre>
@@ -1833,7 +1833,7 @@ for a min function that chooses the least of a list of integers:
 </p>
 <pre>
 func Min(a ...int) int {
-    min := int(^uint(0) &gt;&gt; 1)  // largest int
+    min := int(^uint(0) >> 1)  // largest int
    for _, i := range a {
        if i &lt; min {
            min = i
@@ -2014,7 +2014,7 @@ then make the receiver for the method a value of that type.
 type ByteSlice []byte

 func (slice ByteSlice) Append(data []byte) []byte {
-    // Body exactly the same as the Append function defined above.
+    // Body exactly the same as above
 }
 </pre>
 <p>
@@ -2238,12 +2238,13 @@ if str, ok := value.(string); ok {

 <h3 id="generality">Generality</h3>
 <p>
-If a type exists only to implement an interface and will
-never have exported methods beyond that interface, there is
-no need to export the type itself.
-Exporting just the interface makes it clear the value has no
-interesting behavior beyond what is described in the
-interface.
+If a type exists only to implement an interface
+and has no exported methods beyond that interface,
+there is no need to export the type itself.
+Exporting just the interface makes it clear that
+it's the behavior that matters, not the implementation,
+and that other implementations with different properties
+can mirror the behavior of the original type.
 It also avoids the need to repeat the documentation
 on every instance of a common method.
 </p>
@@ -2409,7 +2410,7 @@ The <code>http</code> package contains this code:
 // Handler object that calls f.
 type HandlerFunc func(ResponseWriter, *Request)

-// ServeHTTP calls f(w, req).
+// ServeHTTP calls f(c, req).
 func (f HandlerFunc) ServeHTTP(w ResponseWriter, req *Request) {
    f(w, req)
 }
@@ -2447,7 +2448,7 @@ the handler installed at that page has value <code>ArgServer</code>
 and type <code>HandlerFunc</code>.
 The HTTP server will invoke the method <code>ServeHTTP</code>
 of that type, with <code>ArgServer</code> as the receiver, which will in turn call
-<code>ArgServer</code> (via the invocation <code>f(w, req)</code>
+<code>ArgServer</code> (via the invocation <code>f(c, req)</code>
 inside <code>HandlerFunc.ServeHTTP</code>).
 The arguments will then be displayed.
 </p>
@@ -3053,7 +3054,7 @@ req := req
 </pre>

 <p>
-but it's legal and idiomatic in Go to do this.
+but it's a legal and idiomatic in Go to do this.
 You get a fresh version of the variable with the same name, deliberately
 shadowing the loop variable locally but unique to each goroutine.
 </p>
@@ -3171,44 +3172,40 @@ count the completion signals by draining the channel after
 launching all the goroutines.
 </p>
 <pre>
-const numCPU = 4 // number of CPU cores
+const NCPU = 4  // number of CPU cores

 func (v Vector) DoAll(u Vector) {
-    c := make(chan int, numCPU)  // Buffering optional but sensible.
-    for i := 0; i &lt; numCPU; i++ {
-        go v.DoSome(i*len(v)/numCPU, (i+1)*len(v)/numCPU, u, c)
+    c := make(chan int, NCPU)  // Buffering optional but sensible.
+    for i := 0; i &lt; NCPU; i++ {
+        go v.DoSome(i*len(v)/NCPU, (i+1)*len(v)/NCPU, u, c)
    }
    // Drain the channel.
-    for i := 0; i &lt; numCPU; i++ {
+    for i := 0; i &lt; NCPU; i++ {
        &lt;-c    // wait for one task to complete
    }
    // All done.
 }
+
 </pre>
+
 <p>
-Rather than create a constant value for numCPU, we can ask the runtime what
-value is appropriate.
-The function <code><a href="/pkg/runtime#NumCPU">runtime.NumCPU</a></code>
-returns the number of hardware CPU cores in the machine, so we could write
+The current implementation of the Go runtime
+will not parallelize this code by default.
+It dedicates only a single core to user-level processing.  An
+arbitrary number of goroutines can be blocked in system calls, but
+by default only one can be executing user-level code at any time.
+It should be smarter and one day it will be smarter, but until it
+is if you want CPU parallelism you must tell the run-time
+how many goroutines you want executing code simultaneously.  There
+are two related ways to do this.  Either run your job with environment
+variable <code>GOMAXPROCS</code> set to the number of cores to use
+or import the <code>runtime</code> package and call
+<code>runtime.GOMAXPROCS(NCPU)</code>.
+A helpful value might be <code>runtime.NumCPU()</code>, which reports the number
+of logical CPUs on the local machine.
+Again, this requirement is expected to be retired as the scheduling and run-time improve.
 </p>
-<pre>
-var numCPU = runtime.NumCPU()
-</pre>
-<p>
-There is also a function
-<code><a href="/pkg/runtime#GOMAXPROCS">runtime.GOMAXPROCS</a></code>,
-which reports (or sets)
-the user-specified number of cores that a Go program can have running
-simultaneously.
-It defaults to the value of <code>runtime.NumCPU</code> but can be
-overridden by setting the similarly named shell environment variable
-or by calling the function with a positive number.  Calling it with
-zero just queries the value.
-Therefore if we want to honor the user's resource request, we should write
-</p>
-<pre>
-var numCPU = runtime.GOMAXPROCS(0)
-</pre>
+
 <p>
 Be sure not to confuse the ideas of concurrency—structuring a program
 as independently executing components—and parallelism—executing
@@ -3664,3 +3661,4 @@ var _ image.Color = Black
 var _ image.Image = Black
 </pre>
 -->
+
--- a/doc/gccgo_contribute.html
+++ b/doc/gccgo_contribute.html
@@ -12,7 +12,7 @@ information on building gccgo for yourself,
 see <a href="/doc/gccgo_install.html">Setting up and using gccgo</a>.
 For more of the gritty details on the process of doing development
 with the gccgo frontend,
-see <a href="https://go.googlesource.com/gofrontend/+/master/HACKING">the
+see <a href="https://code.google.com/p/gofrontend/source/browse/HACKING">the
 file HACKING</a> in the gofrontend repository.
 </p>

@@ -30,9 +30,7 @@ contribution rules</a>.

 <p>
 The master sources for the gccgo frontend may be found at
-<a href="http://go.googlesource.com/gofrontend">http://go.googlesource.com/gofrontend</a>.
-They are mirrored
-at <a href="http://github.com/golang/gofrontend">http://github.com/golang/gofrontend</a>.
+<a href="//code.google.com/p/gofrontend">http://code.google.com/p/gofrontend</a>.
 The master sources are not buildable by themselves, but only in
 conjunction with GCC (in the future, other compilers may be
 supported).  Changes made to the gccgo frontend are also applied to
@@ -42,7 +40,7 @@ is mirrored to the <code>gcc/go/gofrontend</code> directory in the GCC
 repository, and the <code>gofrontend</code> <code>libgo</code>
 directory is mirrored to the GCC <code>libgo</code> directory.  In
 addition, the <code>test</code> directory
-from <a href="//go.googlesource.com/go">the main Go repository</a>
+from <a href="//code.google.com/p/go">the main Go repository</a>
 is mirrored to the <code>gcc/testsuite/go.test/test</code> directory
 in the GCC repository.
 </p>
@@ -55,17 +53,19 @@ them.
 </p>

 <p>
-The gccgo frontend is written in C++.
-It follows the GNU and GCC coding standards for C++.
-In writing code for the frontend, follow the formatting of the
-surrounding code.
-Almost all GCC-specific code is not in the frontend proper and is
-instead in the GCC sources in the <code>gcc/go</code> directory.
+The gccgo frontend is written in C++.  It follows the GNU coding
+standards to the extent that they apply to C++.  In writing code for
+the frontend, follow the formatting of the surrounding code.  Although
+the frontend is currently tied to the rest of the GCC codebase, we
+plan to make it more independent.  Eventually all GCC-specific code
+will migrate out of the frontend proper and into GCC proper.  In the
+GCC sources this will generally mean moving code
+from <code>gcc/go/gofrontend</code> to <code>gcc/go</code>.
 </p>

 <p>
 The run-time library for gccgo is mostly the same as the library
-in <a href="//go.googlesource.com/go">the main Go repository</a>.
+in <a href="//code.google.com/p/go">the main Go repository</a>.
 The library code in the Go repository is periodically merged into
 the <code>libgo/go</code> directory of the <code>gofrontend</code> and
 then the GCC repositories, using the shell
@@ -105,7 +105,7 @@ or <code>gcc/testsuite/go.dg</code> directories in the GCC repository.
 <p>
 Changes to the Go frontend should follow the same process as for the
 main Go repository, only for the <code>gofrontend</code> project and
-the <code>gofrontend-dev@googlegroups.com</code> mailing list 
+the<code>gofrontend-dev@googlegroups.com</code> mailing list 
 rather than the <code>go</code> project and the
 <code>golang-dev@googlegroups.com</code> mailing list.  Those changes
 will then be merged into the GCC sources.
--- a/doc/gccgo_install.html
+++ b/doc/gccgo_install.html
@@ -46,25 +46,6 @@ identical to Go 1.1.  The GCC 4.8.2 release includes a complete Go
 The GCC 4.9 releases include a complete Go 1.2 implementation.
 </p>

-<p>
-The GCC 5 releases include a complete implementation of the Go 1.4
-user libraries.  The Go 1.4 runtime is not fully merged, but that
-should not be visible to Go programs.
-</p>
-
-<p>
-The GCC 6 releases include a complete implementation of the Go 1.6.1
-user libraries.  The Go 1.6 runtime is not fully merged, but that
-should not be visible to Go programs.
-</p>
-
-<p>
-The GCC 7 releases are expected to include a complete implementation
-of the Go 1.8 user libraries.  As with earlier releases, the Go 1.8
-runtime is not fully merged, but that should not be visible to Go
-programs.
-</p>
-
 <h2 id="Source_code">Source code</h2>

 <p>
@@ -173,13 +154,33 @@ make
 make install
 </pre>

+<h3 id="Ubuntu">A note on Ubuntu</h3>
+
+<p>
+Current versions of Ubuntu and versions of GCC before 4.8 disagree on
+where system libraries and header files are found.  This is not a
+gccgo issue.  When building older versions of GCC, setting these
+environment variables while configuring and building gccgo may fix the
+problem.
+</p>
+
+<pre>
+LIBRARY_PATH=/usr/lib/x86_64-linux-gnu
+C_INCLUDE_PATH=/usr/include/x86_64-linux-gnu
+CPLUS_INCLUDE_PATH=/usr/include/x86_64-linux-gnu
+export LIBRARY_PATH C_INCLUDE_PATH CPLUS_INCLUDE_PATH
+</pre>
+
 <h2 id="Using_gccgo">Using gccgo</h2>

 <p>
-The gccgo compiler works like other gcc frontends.  As of GCC 5 the gccgo
-installation also includes a version of the <code>go</code> command,
-which may be used to build Go programs as described at
-<a href="https://golang.org/cmd/go">https://golang.org/cmd/go</a>.
+The gccgo compiler works like other gcc frontends.  The gccgo
+installation does not currently include a version of
+the <code>go</code> command.  However if you have the <code>go</code>
+command from an installation of the <code>gc</code> compiler, you can
+use it with gccgo by passing the option <code>-compiler gccgo</code>
+to <code>go build</code> or <code>go install</code> or <code>go
+test</code>.
 </p>

 <p>
@@ -231,14 +232,13 @@ name the directory where <code>libgo.so</code> is found.

 <li>
 <p>
-Passing a <code>-Wl,-R</code> option when you link (replace lib with
-lib64 if appropriate for your system):
+Passing a <code>-Wl,-R</code> option when you link:
 </p>

 <pre>
-go build -gccgoflags -Wl,-R,${prefix}/lib/gcc/MACHINE/VERSION
-[or]
 gccgo -o file file.o -Wl,-R,${prefix}/lib/gcc/MACHINE/VERSION
+[or]
+gccgo -o file file.o -Wl,-R,${prefix}/lib64/gcc/MACHINE/VERSION
 </pre>
 </li>

@@ -266,33 +266,27 @@ and <code>-g</code> options.
 </p>

 <p>
-The <code>-fgo-pkgpath=PKGPATH</code> option may be used to set a
-unique prefix for the package being compiled.
-This option is automatically used by the go command, but you may want
-to use it if you invoke gccgo directly.
-This option is intended for use with large
-programs that contain many packages, in order to allow multiple
-packages to use the same identifier as the package name.
-The <code>PKGPATH</code> may be any string; a good choice for the
-string is the path used to import the package.
+The <code>-fgo-prefix=PREFIX</code> option may be used to set a unique
+prefix for the package being compiled.  This option is intended for
+use with large programs that contain many packages, in order to allow
+multiple packages to use the same identifier as the package name.
+The <code>PREFIX</code> may be any string; a good choice for the
+string is the directory where the package will be installed.
 </p>

 <p>
 The <code>-I</code> and <code>-L</code> options, which are synonyms
 for the compiler, may be used to set the search path for finding
 imports.
-These options are not needed if you build with the go command.
 </p>

 <h2 id="Imports">Imports</h2>

 <p>
 When you compile a file that exports something, the export
-information will be stored directly in the object file.
-If you build with gccgo directly, rather than with the go command,
-then when you import a package, you must tell gccgo how to find the
-file.
-</p>
+information will be stored directly in the object file.  When
+you import a package, you must tell gccgo how to
+find the file.

 <p>
 When you import the package <var>FILE</var> with gccgo,
@@ -325,10 +319,9 @@ gccgo.  Both options take directories to search. The
 </p>

 <p>
-The gccgo compiler does not currently (2015-06-15) record
+The gccgo compiler does not currently (2013-06-20) record
 the file name of imported packages in the object file. You must
 arrange for the imported data to be linked into the program.
-Again, this is not necessary when building with the go command.
 </p>

 <pre>
@@ -360,15 +353,12 @@ or with C++ code compiled using <code>extern "C"</code>.
 <h3 id="Types">Types</h3>

 <p>
-Basic types map directly: an <code>int32</code> in Go is
-an <code>int32_t</code> in C, an <code>int64</code> is
-an <code>int64_t</code>, etc.
-The Go type <code>int</code> is an integer that is the same size as a
-pointer, and as such corresponds to the C type <code>intptr_t</code>.
-Go <code>byte</code> is equivalent to C <code>unsigned char</code>.
-Pointers in Go are pointers in C.
-A Go <code>struct</code> is the same as C <code>struct</code> with the
-same fields and types.
+Basic types map directly: an <code>int</code> in Go is an <code>int</code>
+in C, an <code>int32</code> is an <code>int32_t</code>,
+etc.  Go <code>byte</code> is equivalent to C <code>unsigned
+char</code>.
+Pointers in Go are pointers in C. A Go <code>struct</code> is the same as C
+<code>struct</code> with the same fields and types.
 </p>

 <p>
@@ -379,7 +369,7 @@ structure (this is <b style="color: red;">subject to change</b>):
 <pre>
 struct __go_string {
  const unsigned char *__data;
-  intptr_t __length;
+  int __length;
 };
 </pre>

@@ -399,8 +389,8 @@ A slice in Go is a structure.  The current definition is
 <pre>
 struct __go_slice {
  void *__values;
-  intptr_t __count;
-  intptr_t __capacity;
+  int __count;
+  int __capacity;
 };
 </pre>

@@ -525,3 +515,15 @@ This procedure is full of unstated caveats and restrictions and we make no
 guarantee that it will not change in the future. It is more useful as a
 starting point for real Go code than as a regular procedure.
 </p>
+
+<h2 id="RTEMS_Port">RTEMS Port</h2>
+<p>
+The gccgo compiler has been ported to <a href="http://www.rtems.com/">
+<code>RTEMS</code></a>. <code>RTEMS</code> is a real-time executive
+that provides a high performance environment for embedded applications
+on a range of processors and embedded hardware. The current gccgo
+port is for x86. The goal is to extend the port to most of the
+<a href="http://www.rtems.org/wiki/index.php/SupportedCPUs">
+architectures supported by <code>RTEMS</code></a>. For more information on the port,
+as well as instructions on how to install it, please see this
+<a href="http://www.rtems.org/wiki/index.php/GCCGoRTEMS"><code>RTEMS</code> Wiki page</a>.
--- a/doc/go1.1.html
+++ b/doc/go1.1.html
@@ -160,7 +160,7 @@ The GCC release schedule does not coincide with the Go release schedule, so some
 The 4.8.0 version of GCC shipped in March, 2013 and includes a nearly-Go 1.1 version of <code>gccgo</code>.
 Its library is a little behind the release, but the biggest difference is that method values are not implemented.
 Sometime around July 2013, we expect 4.8.2 of GCC to ship with a <code>gccgo</code>
-providing a complete Go 1.1 implementation.
+providing a complete Go 1.1 implementaiton.
 </p>

 <h3 id="gc_flag">Command-line flag parsing</h3>
--- a/doc/go1.3.html
+++ b/doc/go1.3.html
@@ -298,7 +298,7 @@ For example,
 <h3 id="godoc">Changes to godoc</h3>
 <p>
 When invoked with the <code>-analysis</code> flag, 
-<a href="//godoc.org/golang.org/x/tools/cmd/godoc">godoc</a>
+<a href="//godoc.org/code.google.com/p/go.tools/cmd/godoc">godoc</a>
 now performs sophisticated <a href="/lib/godoc/analysis/help.html">static
 analysis</a> of the code it indexes.  
 The results of analysis are presented in both the source view and the
@@ -318,7 +318,7 @@ call sites and their callees.
 The program <code>misc/benchcmp</code> that compares
 performance across benchmarking runs has been rewritten.
 Once a shell and awk script in the main repository, it is now a Go program in the <code>go.tools</code> repo.
-Documentation is <a href="//godoc.org/golang.org/x/tools/cmd/benchcmp">here</a>.
+Documentation is <a href="//godoc.org/code.google.com/p/go.tools/cmd/benchcmp">here</a>.
 </p>

 <p>
--- a/doc/go1.4.html
+++ b/doc/go1.4.html
@@ -8,15 +8,9 @@

 <p>
 The latest Go release, version 1.4, arrives as scheduled six months after 1.3.
-</p>
-
-<p>
 It contains only one tiny language change,
 in the form of a backwards-compatible simple variant of <code>for</code>-<code>range</code> loop,
 and a possibly breaking change to the compiler involving methods on pointers-to-pointers.
-</p>
-
-<p>
 The release focuses primarily on implementation work, improving the garbage collector
 and preparing the ground for a fully concurrent collector to be rolled out in the
 next few releases.
@@ -27,9 +21,6 @@ There are some new tools available including support in the <code>go</code> comm
 for build-time source code generation.
 The release also adds support for ARM processors on Android and Native Client (NaCl)
 and for AMD64 on Plan 9.
-</p>
-
-<p>
 As always, Go 1.4 keeps the <a href="/doc/go1compat.html">promise
 of compatibility</a>,
 and almost everything 
@@ -44,7 +35,7 @@ Up until Go 1.3, <code>for</code>-<code>range</code> loop had two forms
 </p>

 <pre>
-for i, v := range x {
+for k, v := range x {
 	...
 }
 </pre>
@@ -54,7 +45,7 @@ and
 </p>

 <pre>
-for i := range x {
+for k := range x {
 	...
 }
 </pre>
@@ -181,7 +172,7 @@ of the documentation.
 <h3 id="runtime">Changes to the runtime</h3>

 <p>
-Prior to Go 1.4, the runtime (garbage collector, concurrency support, interface management,
+Up to Go 1.4, the runtime (garbage collector, concurrency support, interface management,
 maps, slices, strings, ...) was mostly written in C, with some assembler support.
 In 1.4, much of the code has been translated to Go so that the garbage collector can scan
 the stacks of programs in the runtime and get accurate information about what variables
@@ -207,7 +198,7 @@ Details are available in <a href="https://golang.org/s/contigstacks">the design

 <p>
 The use of contiguous stacks means that stacks can start smaller without triggering performance issues,
-so the default starting size for a goroutine's stack in 1.4 has been reduced from 8192 bytes to 2048 bytes.
+so the default starting size for a goroutine's stack in 1.4 has been reduced to 2048 bytes from 8192 bytes.
 </p>

 <p>
@@ -522,7 +513,10 @@ have been updated.
 <h3 id="swig">SWIG</h3>

 <p>
-Due to runtime changes in this release, Go 1.4 requires SWIG 3.0.3.
+Due to the runtime changes in this release, Go 1.4 will require SWIG 3.0.3.
+At time of writing that has not yet been released, but we expect it to be by
+Go 1.4's release date.
+TODO
 </p>

 <h3 id="misc">Miscellany</h3>
@@ -541,7 +535,7 @@ editor, even for editors we do not use.
 The Go community at large is much better suited to managing this information.
 In Go 1.4, therefore, this support has been removed from the repository.
 Instead, there is a curated, informative list of what's available on
-a <a href="//golang.org/wiki/IDEsAndTextEditorPlugins">wiki page</a>.
+a <a href="https://code.google.com/p/go-wiki/wiki/IDEsAndTextEditorPlugins">wiki page</a>.
 </p>

 <h2 id="performance">Performance</h2>
@@ -677,7 +671,7 @@ now supports ALPN as defined in <a href="http://tools.ietf.org/html/rfc7301">RFC
 The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
 now supports programmatic selection of server certificates
 through the new <a href="/pkg/crypto/tls/#Config.CertificateForName"><code>CertificateForName</code></a> function
-of the <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> struct.
+of the <a href="/pkg/crypo/tls/#Config"><code>Config</code></a> struct.
 </li>

 <li>
--- a/doc/go1.5.html
+++ b/doc/go1.5.html
--- a/doc/go1.6.html
+++ b/doc/go1.6.html
@@ -1,923 +0,0 @@
-<!--{
-	"Title": "Go 1.6 Release Notes",
-	"Path":  "/doc/go1.6",
-	"Template": true
-}-->
-
-<!--
-Edit .,s;^PKG:([a-z][A-Za-z0-9_/]+);<a href="/pkg/\1/"><code>\1</code></a>;g
-Edit .,s;^([a-z][A-Za-z0-9_/]+)\.([A-Z][A-Za-z0-9_]+\.)?([A-Z][A-Za-z0-9_]+)([ .',]|$);<a href="/pkg/\1/#\2\3"><code>\3</code></a>\4;g
-->
-
-<style>
-ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">Introduction to Go 1.6</h2>
-
-<p>
-The latest Go release, version 1.6, arrives six months after 1.5.
-Most of its changes are in the implementation of the language, runtime, and libraries.
-There are no changes to the language specification.
-As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
-We expect almost all Go programs to continue to compile and run as before.
-</p>
-
-<p>
-The release adds new ports to <a href="#ports">Linux on 64-bit MIPS and Android on 32-bit x86</a>;
-defined and enforced <a href="#cgo">rules for sharing Go pointers with C</a>;
-transparent, automatic <a href="#http2">support for HTTP/2</a>;
-and a new mechanism for <a href="#template">template reuse</a>.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-There are no language changes in this release.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p>
-Go 1.6 adds experimental ports to
-Linux on 64-bit MIPS (<code>linux/mips64</code> and <code>linux/mips64le</code>).
-These ports support <code>cgo</code> but only with internal linking.
-</p>
-
-<p>
-Go 1.6 also adds an experimental port to Android on 32-bit x86 (<code>android/386</code>).
-</p>
-
-<p>
-On FreeBSD, Go 1.6 defaults to using <code>clang</code>, not <code>gcc</code>, as the external C compiler.
-</p>
-
-<p>
-On Linux on little-endian 64-bit PowerPC (<code>linux/ppc64le</code>),
-Go 1.6 now supports <code>cgo</code> with external linking and
-is roughly feature complete.
-</p>
-
-<p>
-On NaCl, Go 1.5 required SDK version pepper-41.
-Go 1.6 adds support for later SDK versions.
-</p>
-
-<p>
-On 32-bit x86 systems using the <code>-dynlink</code> or <code>-shared</code> compilation modes,
-the register CX is now overwritten by certain memory references and should
-be avoided in hand-written assembly.
-See the <a href="/doc/asm#x86">assembly documentation</a> for details.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="cgo">Cgo</h3>
-
-<p>
-There is one major change to <a href="/cmd/cgo/"><code>cgo</code></a>, along with one minor change.
-</p>
-
-<p>
-The major change is the definition of rules for sharing Go pointers with C code,
-to ensure that such C code can coexist with Go's garbage collector.
-Briefly, Go and C may share memory allocated by Go
-when a pointer to that memory is passed to C as part of a <code>cgo</code> call,
-provided that the memory itself contains no pointers to Go-allocated memory,
-and provided that C does not retain the pointer after the call returns.
-These rules are checked by the runtime during program execution:
-if the runtime detects a violation, it prints a diagnosis and crashes the program.
-The checks can be disabled by setting the environment variable
-<code>GODEBUG=cgocheck=0</code>, but note that the vast majority of
-code identified by the checks is subtly incompatible with garbage collection
-in one way or another.
-Disabling the checks will typically only lead to more mysterious failure modes.
-Fixing the code in question should be strongly preferred
-over turning off the checks.
-See the <a href="/cmd/cgo/#hdr-Passing_pointers"><code>cgo</code> documentation</a> for more details.
-</p>
-
-<p>
-The minor change is
-the addition of explicit <code>C.complexfloat</code> and <code>C.complexdouble</code> types,
-separate from Go's <code>complex64</code> and <code>complex128</code>.
-Matching the other numeric types, C's complex types and Go's complex type are
-no longer interchangeable.
-</p>
-
-<h3 id="compiler">Compiler Toolchain</h3>
-
-<p>
-The compiler toolchain is mostly unchanged.
-Internally, the most significant change is that the parser is now hand-written
-instead of generated from <a href="/cmd/yacc/">yacc</a>.
-</p>
-
-<p>
-The compiler, linker, and <code>go</code> command have a new flag <code>-msan</code>,
-analogous to <code>-race</code> and only available on linux/amd64,
-that enables interoperation with the <a href="http://clang.llvm.org/docs/MemorySanitizer.html">Clang MemorySanitizer</a>.
-Such interoperation is useful mainly for testing a program containing suspect C or C++ code.
-</p>
-
-<p>
-The linker has a new option <code>-libgcc</code> to set the expected location
-of the C compiler support library when linking <a href="/cmd/cgo/"><code>cgo</code></a> code.
-The option is only consulted when using <code>-linkmode=internal</code>,
-and it may be set to <code>none</code> to disable the use of a support library.
-</p>
-
-<p>
-The implementation of <a href="/doc/go1.5#link">build modes started in Go 1.5</a> has been expanded to more systems.
-This release adds support for the <code>c-shared</code> mode on <code>android/386</code>, <code>android/amd64</code>,
-<code>android/arm64</code>, <code>linux/386</code>, and <code>linux/arm64</code>;
-for the <code>shared</code> mode on <code>linux/386</code>, <code>linux/arm</code>, <code>linux/amd64</code>, and <code>linux/ppc64le</code>;
-and for the new <code>pie</code> mode (generating position-independent executables) on
-<code>android/386</code>, <code>android/amd64</code>, <code>android/arm</code>, <code>android/arm64</code>, <code>linux/386</code>,
-<code>linux/amd64</code>, <code>linux/arm</code>, <code>linux/arm64</code>, and <code>linux/ppc64le</code>.
-See the <a href="https://golang.org/s/execmodes">design document</a> for details.
-</p>
-
-<p>
-As a reminder, the linker's <code>-X</code> flag changed in Go 1.5.
-In Go 1.4 and earlier, it took two arguments, as in
-</p>
-
-<pre>
-X importpath.name value
-</pre>
-
-<p>
-Go 1.5 added an alternative syntax using a single argument
-that is itself a <code>name=value</code> pair:
-</p>
-
-<pre>
-X importpath.name=value
-</pre>
-
-<p>
-In Go 1.5 the old syntax was still accepted, after printing a warning
-suggesting use of the new syntax instead.
-Go 1.6 continues to accept the old syntax and print the warning.
-Go 1.7 will remove support for the old syntax.
-</p>
-
-<h3 id="gccgo">Gccgo</h3>
-
-<p>
-The release schedules for the GCC and Go projects do not coincide.
-GCC release 5 contains the Go 1.4 version of gccgo.
-The next release, GCC 6, will have the Go 1.6.1 version of gccgo.
-</p>
-
-<h3 id="go_command">Go command</h3>
-
-<p>
-The <a href="/cmd/go"><code>go</code></a> command's basic operation
-is unchanged, but there are a number of changes worth noting.
-</p>
-
-<p>
-Go 1.5 introduced experimental support for vendoring,
-enabled by setting the <code>GO15VENDOREXPERIMENT</code> environment variable to <code>1</code>.
-Go 1.6 keeps the vendoring support, no longer considered experimental,
-and enables it by default.
-It can be disabled explicitly by setting
-the <code>GO15VENDOREXPERIMENT</code> environment variable to <code>0</code>.
-Go 1.7 will remove support for the environment variable.
-</p>
-
-<p>
-The most likely problem caused by enabling vendoring by default happens
-in source trees containing an existing directory named <code>vendor</code> that
-does not expect to be interpreted according to new vendoring semantics.
-In this case, the simplest fix is to rename the directory to anything other
-than <code>vendor</code> and update any affected import paths.
-</p>
-
-<p>
-For details about vendoring,
-see the documentation for the <a href="/cmd/go/#hdr-Vendor_Directories"><code>go</code> command</a>
-and the <a href="https://golang.org/s/go15vendor">design document</a>.
-</p>
-
-<p>
-There is a new build flag, <code>-msan</code>,
-that compiles Go with support for the LLVM memory sanitizer.
-This is intended mainly for use when linking against C or C++ code
-that is being checked with the memory sanitizer.
-</p>
-
-<h3 id="doc_command">Go doc command</h3>
-
-<p>
-Go 1.5 introduced the
-<a href="/cmd/go/#hdr-Show_documentation_for_package_or_symbol"><code>go doc</code></a> command,
-which allows references to packages using only the package name, as in
-<code>go</code> <code>doc</code> <code>http</code>.
-In the event of ambiguity, the Go 1.5 behavior was to use the package
-with the lexicographically earliest import path.
-In Go 1.6, ambiguity is resolved by preferring import paths with
-fewer elements, breaking ties using lexicographic comparison.
-An important effect of this change is that original copies of packages
-are now preferred over vendored copies.
-Successful searches also tend to run faster.
-</p>
-
-<h3 id="vet_command">Go vet command</h3>
-
-<p>
-The <a href="/cmd/vet"><code>go vet</code></a> command now diagnoses
-passing function or method values as arguments to <code>Printf</code>,
-such as when passing <code>f</code> where <code>f()</code> was intended.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-As always, the changes are so general and varied that precise statements
-about performance are difficult to make.
-Some programs may run faster, some slower.
-On average the programs in the Go 1 benchmark suite run a few percent faster in Go 1.6
-than they did in Go 1.5.
-The garbage collector's pauses are even lower than in Go 1.5,
-especially for programs using
-a large amount of memory.
-</p>
-
-<p>
-There have been significant optimizations bringing more than 10% improvements
-to implementations of the
-<a href="/pkg/compress/bzip2/"><code>compress/bzip2</code></a>,
-<a href="/pkg/compress/gzip/"><code>compress/gzip</code></a>,
-<a href="/pkg/crypto/aes/"><code>crypto/aes</code></a>,
-<a href="/pkg/crypto/elliptic/"><code>crypto/elliptic</code></a>,
-<a href="/pkg/crypto/ecdsa/"><code>crypto/ecdsa</code></a>, and
-<a href="/pkg/sort/"><code>sort</code></a> packages.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<h3 id="http2">HTTP/2</h3>
-
-<p>
-Go 1.6 adds transparent support in the
-<a href="/pkg/net/http/"><code>net/http</code></a> package
-for the new <a href="https://http2.github.io/">HTTP/2 protocol</a>.
-Go clients and servers will automatically use HTTP/2 as appropriate when using HTTPS.
-There is no exported API specific to details of the HTTP/2 protocol handling,
-just as there is no exported API specific to HTTP/1.1.
-</p>
-
-<p>
-Programs that must disable HTTP/2 can do so by setting
-<a href="/pkg/net/http/#Transport"><code>Transport.TLSNextProto</code></a> (for clients)
-or
-<a href="/pkg/net/http/#Server"><code>Server.TLSNextProto</code></a> (for servers)
-to a non-nil, empty map.
-</p>
-
-<p>
-Programs that must adjust HTTP/2 protocol-specific details can import and use
-<a href="https://golang.org/x/net/http2"><code>golang.org/x/net/http2</code></a>,
-in particular its
-<a href="https://godoc.org/golang.org/x/net/http2/#ConfigureServer">ConfigureServer</a>
-and
-<a href="https://godoc.org/golang.org/x/net/http2/#ConfigureTransport">ConfigureTransport</a>
-functions.
-</p>
-
-<h3 id="runtime">Runtime</h3>
-
-<p>
-The runtime has added lightweight, best-effort detection of concurrent misuse of maps.
-As always, if one goroutine is writing to a map, no other goroutine should be
-reading or writing the map concurrently.
-If the runtime detects this condition, it prints a diagnosis and crashes the program.
-The best way to find out more about the problem is to run the program
-under the
-<a href="https://blog.golang.org/race-detector">race detector</a>,
-which will more reliably identify the race
-and give more detail.
-</p>
-
-<p>
-For program-ending panics, the runtime now by default
-prints only the stack of the running goroutine,
-not all existing goroutines.
-Usually only the current goroutine is relevant to a panic,
-so omitting the others significantly reduces irrelevant output
-in a crash message.
-To see the stacks from all goroutines in crash messages, set the environment variable
-<code>GOTRACEBACK</code> to <code>all</code>
-or call
-<a href="/pkg/runtime/debug/#SetTraceback"><code>debug.SetTraceback</code></a>
-before the crash, and rerun the program.
-See the <a href="/pkg/runtime/#hdr-Environment_Variables">runtime documentation</a> for details.
-</p>
-
-<p>
-<em>Updating</em>:
-Uncaught panics intended to dump the state of the entire program,
-such as when a timeout is detected or when explicitly handling a received signal,
-should now call <code>debug.SetTraceback("all")</code> before panicking.
-Searching for uses of
-<a href="/pkg/os/signal/#Notify"><code>signal.Notify</code></a> may help identify such code.
-</p>
-
-<p>
-On Windows, Go programs in Go 1.5 and earlier forced
-the global Windows timer resolution to 1ms at startup
-by calling <code>timeBeginPeriod(1)</code>.
-Go no longer needs this for good scheduler performance,
-and changing the global timer resolution caused problems on some systems,
-so the call has been removed.
-</p>
-
-<p>
-When using <code>-buildmode=c-archive</code> or
-<code>-buildmode=c-shared</code> to build an archive or a shared
-library, the handling of signals has changed.
-In Go 1.5 the archive or shared library would install a signal handler
-for most signals.
-In Go 1.6 it will only install a signal handler for the
-synchronous signals needed to handle run-time panics in Go code:
-SIGBUS, SIGFPE, SIGSEGV.
-See the <a href="/pkg/os/signal">os/signal</a> package for more
-details.
-</p>
-
-<h3 id="reflect">Reflect</h3>
-
-<p>
-The
-<a href="/pkg/reflect/"><code>reflect</code></a> package has
-<a href="https://golang.org/issue/12367">resolved a long-standing incompatibility</a>
-between the gc and gccgo toolchains
-regarding embedded unexported struct types containing exported fields.
-Code that walks data structures using reflection, especially to implement
-serialization in the spirit
-of the
-<a href="/pkg/encoding/json/"><code>encoding/json</code></a> and
-<a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> packages,
-may need to be updated.
-</p>
-
-<p>
-The problem arises when using reflection to walk through
-an embedded unexported struct-typed field
-into an exported field of that struct.
-In this case, <code>reflect</code> had incorrectly reported
-the embedded field as exported, by returning an empty <code>Field.PkgPath</code>.
-Now it correctly reports the field as unexported
-but ignores that fact when evaluating access to exported fields
-contained within the struct.
-</p>
-
-<p>
-<em>Updating</em>:
-Typically, code that previously walked over structs and used
-</p>
-
-<pre>
-f.PkgPath != ""
-</pre>
-
-<p>
-to exclude inaccessible fields
-should now use
-</p>
-
-<pre>
-f.PkgPath != "" &amp;&amp; !f.Anonymous
-</pre>
-
-<p>
-For example, see the changes to the implementations of
-<a href="https://go-review.googlesource.com/#/c/14011/2/src/encoding/json/encode.go"><code>encoding/json</code></a> and
-<a href="https://go-review.googlesource.com/#/c/14012/2/src/encoding/xml/typeinfo.go"><code>encoding/xml</code></a>.
-</p>
-
-<h3 id="sort">Sorting</h3>
-
-<p>
-In the
-<a href="/pkg/sort/"><code>sort</code></a>
-package,
-the implementation of
-<a href="/pkg/sort/#Sort"><code>Sort</code></a>
-has been rewritten to make about 10% fewer calls to the
-<a href="/pkg/sort/#Interface"><code>Interface</code></a>'s
-<code>Less</code> and <code>Swap</code>
-methods, with a corresponding overall time savings.
-The new algorithm does choose a different ordering than before
-for values that compare equal (those pairs for which <code>Less(i,</code> <code>j)</code> and <code>Less(j,</code> <code>i)</code> are false).
-</p>
-
-<p>
-<em>Updating</em>:
-The definition of <code>Sort</code> makes no guarantee about the final order of equal values,
-but the new behavior may still break programs that expect a specific order.
-Such programs should either refine their <code>Less</code> implementations
-to report the desired order
-or should switch to
-<a href="/pkg/sort/#Stable"><code>Stable</code></a>,
-which preserves the original input order
-of equal values.
-</p>
-
-<h3 id="template">Templates</h3>
-
-<p>
-In the
-<a href="/pkg/text/template/">text/template</a> package,
-there are two significant new features to make writing templates easier.
-</p>
-
-<p>
-First, it is now possible to <a href="/pkg/text/template/#hdr-Text_and_spaces">trim spaces around template actions</a>,
-which can make template definitions more readable.
-A minus sign at the beginning of an action says to trim space before the action,
-and a minus sign at the end of an action says to trim space after the action.
-For example, the template
-</p>
-
-<pre>
-{{"{{"}}23 -}}
-   &lt;
-{{"{{"}}- 45}}
-</pre>
-
-<p>
-formats as <code>23&lt;45</code>.
-</p>
-
-<p>
-Second, the new <a href="/pkg/text/template/#hdr-Actions"><code>{{"{{"}}block}}</code> action</a>,
-combined with allowing redefinition of named templates,
-provides a simple way to define pieces of a template that
-can be replaced in different instantiations.
-There is <a href="/pkg/text/template/#example_Template_block">an example</a>
-in the <code>text/template</code> package that demonstrates this new feature.
-</p>
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<ul>
-
-<li>
-The <a href="/pkg/archive/tar/"><code>archive/tar</code></a> package's
-implementation corrects many bugs in rare corner cases of the file format.
-One visible change is that the
-<a href="/pkg/archive/tar/#Reader"><code>Reader</code></a> type's
-<a href="/pkg/archive/tar/#Reader.Read"><code>Read</code></a> method
-now presents the content of special file types as being empty,
-returning <code>io.EOF</code> immediately.
-</li>
-
-<li>
-In the <a href="/pkg/archive/zip/"><code>archive/zip</code></a> package, the
-<a href="/pkg/archive/zip/#Reader"><code>Reader</code></a> type now has a
-<a href="/pkg/archive/zip/#Reader.RegisterDecompressor"><code>RegisterDecompressor</code></a> method,
-and the
-<a href="/pkg/archive/zip/#Writer"><code>Writer</code></a> type now has a
-<a href="/pkg/archive/zip/#Writer.RegisterCompressor"><code>RegisterCompressor</code></a> method,
-enabling control over compression options for individual zip files.
-These take precedence over the pre-existing global
-<a href="/pkg/archive/zip/#RegisterDecompressor"><code>RegisterDecompressor</code></a> and
-<a href="/pkg/archive/zip/#RegisterCompressor"><code>RegisterCompressor</code></a> functions.
-</li>
-
-<li>
-The <a href="/pkg/bufio/"><code>bufio</code></a> package's
-<a href="/pkg/bufio/#Scanner"><code>Scanner</code></a> type now has a
-<a href="/pkg/bufio/#Scanner.Buffer"><code>Buffer</code></a> method,
-to specify an initial buffer and maximum buffer size to use during scanning.
-This makes it possible, when needed, to scan tokens larger than
-<code>MaxScanTokenSize</code>.
-Also for the <code>Scanner</code>, the package now defines the
-<a href="/pkg/bufio/#ErrFinalToken"><code>ErrFinalToken</code></a> error value, for use by
-<a href="/pkg/bufio/#SplitFunc">split functions</a> to abort processing or to return a final empty token.
-</li>
-
-<li>
-The <a href="/pkg/compress/flate/"><code>compress/flate</code></a> package
-has deprecated its
-<a href="/pkg/compress/flate/#ReadError"><code>ReadError</code></a> and
-<a href="/pkg/compress/flate/#WriteError"><code>WriteError</code></a> error implementations.
-In Go 1.5 they were only rarely returned when an error was encountered;
-now they are never returned, although they remain defined for compatibility.
-</li>
-
-<li>
-The <a href="/pkg/compress/flate/"><code>compress/flate</code></a>,
-<a href="/pkg/compress/gzip/"><code>compress/gzip</code></a>, and
-<a href="/pkg/compress/zlib/"><code>compress/zlib</code></a> packages
-now report
-<a href="/pkg/io/#ErrUnexpectedEOF"><code>io.ErrUnexpectedEOF</code></a> for truncated input streams, instead of
-<a href="/pkg/io/#EOF"><code>io.EOF</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/crypto/cipher/"><code>crypto/cipher</code></a> package now
-overwrites the destination buffer in the event of a GCM decryption failure.
-This is to allow the AESNI code to avoid using a temporary buffer.
-</li>
-
-<li>
-The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
-has a variety of minor changes.
-It now allows
-<a href="/pkg/crypto/tls/#Listen"><code>Listen</code></a>
-to succeed when the
-<a href="/pkg/crypto/tls/#Config"><code>Config</code></a>
-has a nil <code>Certificates</code>, as long as the <code>GetCertificate</code> callback is set,
-it adds support for RSA with AES-GCM cipher suites,
-and
-it adds a
-<a href="/pkg/crypto/tls/#RecordHeaderError"><code>RecordHeaderError</code></a>
-to allow clients (in particular, the <a href="/pkg/net/http/"><code>net/http</code></a> package)
-to report a better error when attempting a TLS connection to a non-TLS server.
-</li>
-
-<li>
-The <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package
-now permits certificates to contain negative serial numbers
-(technically an error, but unfortunately common in practice),
-and it defines a new
-<a href="/pkg/crypto/x509/#InsecureAlgorithmError"><code>InsecureAlgorithmError</code></a>
-to give a better error message when rejecting a certificate
-signed with an insecure algorithm like MD5.
-</li>
-
-<li>
-The <a href="/pkg/debug/dwarf"><code>debug/dwarf</code></a> and
-<a href="/pkg/debug/elf/"><code>debug/elf</code></a> packages
-together add support for compressed DWARF sections.
-User code needs no updating: the sections are decompressed automatically when read.
-</li>
-
-<li>
-The <a href="/pkg/debug/elf/"><code>debug/elf</code></a> package
-adds support for general compressed ELF sections.
-User code needs no updating: the sections are decompressed automatically when read.
-However, compressed
-<a href="/pkg/debug/elf/#Section"><code>Sections</code></a> do not support random access:
-they have a nil <code>ReaderAt</code> field.
-</li>
-
-<li>
-The <a href="/pkg/encoding/asn1/"><code>encoding/asn1</code></a> package
-now exports
-<a href="/pkg/encoding/asn1/#pkg-constants">tag and class constants</a>
-useful for advanced parsing of ASN.1 structures.
-</li>
-
-<li>
-Also in the <a href="/pkg/encoding/asn1/"><code>encoding/asn1</code></a> package,
-<a href="/pkg/encoding/asn1/#Unmarshal"><code>Unmarshal</code></a> now rejects various non-standard integer and length encodings.
-</li>
-
-<li>
-The <a href="/pkg/encoding/base64"><code>encoding/base64</code></a> package's
-<a href="/pkg/encoding/base64/#Decoder"><code>Decoder</code></a> has been fixed
-to process the final bytes of its input. Previously it processed as many four-byte tokens as
-possible but ignored the remainder, up to three bytes.
-The <code>Decoder</code> therefore now handles inputs in unpadded encodings (like
-<a href="/pkg/encoding/base64/#RawURLEncoding">RawURLEncoding</a>) correctly,
-but it also rejects inputs in padded encodings that are truncated or end with invalid bytes,
-such as trailing spaces.
-</li>
-
-<li>
-The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package
-now checks the syntax of a
-<a href="/pkg/encoding/json/#Number"><code>Number</code></a>
-before marshaling it, requiring that it conforms to the JSON specification for numeric values.
-As in previous releases, the zero <code>Number</code> (an empty string) is marshaled as a literal 0 (zero).
-</li>
-
-<li>
-The <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package's
-<a href="/pkg/encoding/xml/#Marshal"><code>Marshal</code></a>
-function now supports a <code>cdata</code> attribute, such as <code>chardata</code>
-but encoding its argument in one or more <code>&lt;![CDATA[ ... ]]&gt;</code> tags.
-</li>
-
-<li>
-Also in the <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package,
-<a href="/pkg/encoding/xml/#Decoder"><code>Decoder</code></a>'s
-<a href="/pkg/encoding/xml/#Decoder.Token"><code>Token</code></a> method
-now reports an error when encountering EOF before seeing all open tags closed,
-consistent with its general requirement that tags in the input be properly matched.
-To avoid that requirement, use
-<a href="/pkg/encoding/xml/#Decoder.RawToken"><code>RawToken</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/fmt/"><code>fmt</code></a> package now allows
-any integer type as an argument to
-<a href="/pkg/fmt/#Printf"><code>Printf</code></a>'s <code>*</code> width and precision specification.
-In previous releases, the argument to <code>*</code> was required to have type <code>int</code>.
-</li>
-
-<li>
-Also in the <a href="/pkg/fmt/"><code>fmt</code></a> package,
-<a href="/pkg/fmt/#Scanf"><code>Scanf</code></a> can now scan hexadecimal strings using %X, as an alias for %x.
-Both formats accept any mix of upper- and lower-case hexadecimal.
-</li>
-
-<li>
-The <a href="/pkg/image/"><code>image</code></a>
-and
-<a href="/pkg/image/color/"><code>image/color</code></a> packages
-add
-<a href="/pkg/image/#NYCbCrA"><code>NYCbCrA</code></a>
-and
-<a href="/pkg/image/color/#NYCbCrA"><code>NYCbCrA</code></a>
-types, to support Y'CbCr images with non-premultiplied alpha.
-</li>
-
-<li>
-The <a href="/pkg/io/"><code>io</code></a> package's
-<a href="/pkg/io/#MultiWriter"><code>MultiWriter</code></a>
-implementation now implements a <code>WriteString</code> method,
-for use by
-<a href="/pkg/io/#WriteString"><code>WriteString</code></a>.
-</li>
-
-<li>
-In the <a href="/pkg/math/big/"><code>math/big</code></a> package,
-<a href="/pkg/math/big/#Int"><code>Int</code></a> adds
-<a href="/pkg/math/big/#Int.Append"><code>Append</code></a>
-and
-<a href="/pkg/math/big/#Int.Text"><code>Text</code></a>
-methods to give more control over printing.
-</li>
-
-<li>
-Also in the <a href="/pkg/math/big/"><code>math/big</code></a> package,
-<a href="/pkg/math/big/#Float"><code>Float</code></a> now implements
-<a href="/pkg/encoding/#TextMarshaler"><code>encoding.TextMarshaler</code></a> and
-<a href="/pkg/encoding/#TextUnmarshaler"><code>encoding.TextUnmarshaler</code></a>,
-allowing it to be serialized in a natural form by the
-<a href="/pkg/encoding/json/"><code>encoding/json</code></a> and
-<a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> packages.
-</li>
-
-<li>
-Also in the <a href="/pkg/math/big/"><code>math/big</code></a> package,
-<a href="/pkg/math/big/#Float"><code>Float</code></a>'s
-<a href="/pkg/math/big/#Float.Append"><code>Append</code></a> method now supports the special precision argument -1.
-As in
-<a href="/pkg/strconv/#ParseFloat"><code>strconv.ParseFloat</code></a>,
-precision -1 means to use the smallest number of digits necessary such that
-<a href="/pkg/math/big/#Float.Parse"><code>Parse</code></a>
-reading the result into a <code>Float</code> of the same precision
-will yield the original value.
-</li>
-
-<li>
-The <a href="/pkg/math/rand/"><code>math/rand</code></a> package
-adds a
-<a href="/pkg/math/rand/#Read"><code>Read</code></a>
-function, and likewise
-<a href="/pkg/math/rand/#Rand"><code>Rand</code></a> adds a
-<a href="/pkg/math/rand/#Rand.Read"><code>Read</code></a> method.
-These make it easier to generate pseudorandom test data.
-Note that, like the rest of the package,
-these should not be used in cryptographic settings;
-for such purposes, use the <a href="/pkg/crypto/rand/"><code>crypto/rand</code></a> package instead.
-</li>
-
-<li>
-The <a href="/pkg/net/"><code>net</code></a> package's
-<a href="/pkg/net/#ParseMAC"><code>ParseMAC</code></a> function now accepts 20-byte IP-over-InfiniBand (IPoIB) link-layer addresses.
-</li>
-
-
-<li>
-Also in the <a href="/pkg/net/"><code>net</code></a> package,
-there have been a few changes to DNS lookups.
-First, the
-<a href="/pkg/net/#DNSError"><code>DNSError</code></a> error implementation now implements
-<a href="/pkg/net/#Error"><code>Error</code></a>,
-and in particular its new
-<a href="/pkg/net/#DNSError.IsTemporary"><code>IsTemporary</code></a>
-method returns true for DNS server errors.
-Second, DNS lookup functions such as
-<a href="/pkg/net/#LookupAddr"><code>LookupAddr</code></a>
-now return rooted domain names (with a trailing dot)
-on Plan 9 and Windows, to match the behavior of Go on Unix systems.
-</li>
-
-<li>
-The <a href="/pkg/net/http/"><code>net/http</code></a> package has
-a number of minor additions beyond the HTTP/2 support already discussed.
-First, the
-<a href="/pkg/net/http/#FileServer"><code>FileServer</code></a> now sorts its generated directory listings by file name.
-Second, the
-<a href="/pkg/net/http/#ServeFile"><code>ServeFile</code></a> function now refuses to serve a result
-if the request's URL path contains &ldquo;..&rdquo; (dot-dot) as a path element.
-Programs should typically use <code>FileServer</code> and 
-<a href="/pkg/net/http/#Dir"><code>Dir</code></a>
-instead of calling <code>ServeFile</code> directly.
-Programs that need to serve file content in response to requests for URLs containing dot-dot can 
-still call <a href="/pkg/net/http/#ServeContent"><code>ServeContent</code></a>.
-Third, the
-<a href="/pkg/net/http/#Client"><code>Client</code></a> now allows user code to set the
-<code>Expect:</code> <code>100-continue</code> header (see
-<a href="/pkg/net/http/#Transport"><code>Transport.ExpectContinueTimeout</code></a>).
-Fourth, there are
-<a href="/pkg/net/http/#pkg-constants">five new error codes</a>:
-<code>StatusPreconditionRequired</code> (428),
-<code>StatusTooManyRequests</code> (429),
-<code>StatusRequestHeaderFieldsTooLarge</code> (431), and
-<code>StatusNetworkAuthenticationRequired</code> (511) from RFC 6585,
-as well as the recently-approved
-<code>StatusUnavailableForLegalReasons</code> (451).
-Fifth, the implementation and documentation of
-<a href="/pkg/net/http/#CloseNotifier"><code>CloseNotifier</code></a>
-has been substantially changed.
-The <a href="/pkg/net/http/#Hijacker"><code>Hijacker</code></a>
-interface now works correctly on connections that have previously
-been used with <code>CloseNotifier</code>.
-The documentation now describes when <code>CloseNotifier</code>
-is expected to work.
-</li>
-
-<li>
-Also in the <a href="/pkg/net/http/"><code>net/http</code></a> package,
-there are a few changes related to the handling of a
-<a href="/pkg/net/http/#Request"><code>Request</code></a> data structure with its <code>Method</code> field set to the empty string.
-An empty <code>Method</code> field has always been documented as an alias for <code>"GET"</code>
-and it remains so.
-However, Go 1.6 fixes a few routines that did not treat an empty
-<code>Method</code> the same as an explicit <code>"GET"</code>.
-Most notably, in previous releases
-<a href="/pkg/net/http/#Client"><code>Client</code></a> followed redirects only with
-<code>Method</code> set explicitly to <code>"GET"</code>;
-in Go 1.6 <code>Client</code> also follows redirects for the empty <code>Method</code>.
-Finally,
-<a href="/pkg/net/http/#NewRequest"><code>NewRequest</code></a> accepts a <code>method</code> argument that has not been
-documented as allowed to be empty.
-In past releases, passing an empty <code>method</code> argument resulted
-in a <code>Request</code> with an empty <code>Method</code> field.
-In Go 1.6, the resulting <code>Request</code> always has an initialized
-<code>Method</code> field: if its argument is an empty string, <code>NewRequest</code>
-sets the <code>Method</code> field in the returned <code>Request</code> to <code>"GET"</code>.
-</li>
-
-<li>
-The <a href="/pkg/net/http/httptest/"><code>net/http/httptest</code></a> package's
-<a href="/pkg/net/http/httptest/#ResponseRecorder"><code>ResponseRecorder</code></a> now initializes a default Content-Type header
-using the same content-sniffing algorithm as in
-<a href="/pkg/net/http/#Server"><code>http.Server</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/net/url/"><code>net/url</code></a> package's
-<a href="/pkg/net/url/#Parse"><code>Parse</code></a> is now stricter and more spec-compliant regarding the parsing
-of host names.
-For example, spaces in the host name are no longer accepted.
-</li>
-
-<li>
-Also in the <a href="/pkg/net/url/"><code>net/url</code></a> package,
-the <a href="/pkg/net/url/#Error"><code>Error</code></a> type now implements
-<a href="/pkg/net/#Error"><code>net.Error</code></a>.
-</li>
-
-<li>
-The <a href="/pkg/os/"><code>os</code></a> package's
-<a href="/pkg/os/#IsExist"><code>IsExist</code></a>,
-<a href="/pkg/os/#IsNotExist"><code>IsNotExist</code></a>,
-and
-<a href="/pkg/os/#IsPermission"><code>IsPermission</code></a>
-now return correct results when inquiring about an
-<a href="/pkg/os/#SyscallError"><code>SyscallError</code></a>.
-</li>
-
-<li>
-On Unix-like systems, when a write
-to <a href="/pkg/os/#pkg-variables"><code>os.Stdout</code>
-or <code>os.Stderr</code></a> (more precisely, an <code>os.File</code>
-opened for file descriptor 1 or 2) fails due to a broken pipe error,
-the program will raise a <code>SIGPIPE</code> signal.
-By default this will cause the program to exit; this may be changed by
-calling the
-<a href="/pkg/os/signal"><code>os/signal</code></a>
-<a href="/pkg/os/signal/#Notify"><code>Notify</code></a> function
-for <code>syscall.SIGPIPE</code>.
-A write to a broken pipe on a file descriptor other 1 or 2 will simply
-return <code>syscall.EPIPE</code> (possibly wrapped in
-<a href="/pkg/os#PathError"><code>os.PathError</code></a>
-and/or <a href="/pkg/os#SyscallError"><code>os.SyscallError</code></a>)
-to the caller.
-The old behavior of raising an uncatchable <code>SIGPIPE</code> signal
-after 10 consecutive writes to a broken pipe no longer occurs.
-</li>
-
-<li>
-In the <a href="/pkg/os/exec/"><code>os/exec</code></a> package,
-<a href="/pkg/os/exec/#Cmd"><code>Cmd</code></a>'s
-<a href="/pkg/os/exec/#Cmd.Output"><code>Output</code></a> method continues to return an
-<a href="/pkg/os/exec/#ExitError"><code>ExitError</code></a> when a command exits with an unsuccessful status.
-If standard error would otherwise have been discarded,
-the returned <code>ExitError</code> now holds a prefix and suffix
-(currently 32 kB) of the failed command's standard error output,
-for debugging or for inclusion in error messages.
-The <code>ExitError</code>'s
-<a href="/pkg/os/exec/#ExitError.String"><code>String</code></a>
-method does not show the captured standard error;
-programs must retrieve it from the data structure
-separately.
-</li>
-
-<li>
-On Windows, the <a href="/pkg/path/filepath/"><code>path/filepath</code></a> package's
-<a href="/pkg/path/filepath/#Join"><code>Join</code></a> function now correctly handles the case when the base is a relative drive path.
-For example, <code>Join(`c:`,</code> <code>`a`)</code> now
-returns <code>`c:a`</code> instead of <code>`c:\a`</code> as in past releases.
-This may affect code that expects the incorrect result.
-</li>
-
-<li>
-In the <a href="/pkg/regexp/"><code>regexp</code></a> package,
-the
-<a href="/pkg/regexp/#Regexp"><code>Regexp</code></a> type has always been safe for use by
-concurrent goroutines.
-It uses a <a href="/pkg/sync/#Mutex"><code>sync.Mutex</code></a> to protect
-a cache of scratch spaces used during regular expression searches.
-Some high-concurrency servers using the same <code>Regexp</code> from many goroutines
-have seen degraded performance due to contention on that mutex.
-To help such servers, <code>Regexp</code> now has a
-<a href="/pkg/regexp/#Regexp.Copy"><code>Copy</code></a> method,
-which makes a copy of a <code>Regexp</code> that shares most of the structure
-of the original but has its own scratch space cache.
-Two goroutines can use different copies of a <code>Regexp</code>
-without mutex contention.
-A copy does have additional space overhead, so <code>Copy</code>
-should only be used when contention has been observed.
-</li>
-
-<li>
-The <a href="/pkg/strconv/"><code>strconv</code></a> package adds
-<a href="/pkg/strconv/#IsGraphic"><code>IsGraphic</code></a>,
-similar to <a href="/pkg/strconv/#IsPrint"><code>IsPrint</code></a>.
-It also adds
-<a href="/pkg/strconv/#QuoteToGraphic"><code>QuoteToGraphic</code></a>,
-<a href="/pkg/strconv/#QuoteRuneToGraphic"><code>QuoteRuneToGraphic</code></a>,
-<a href="/pkg/strconv/#AppendQuoteToGraphic"><code>AppendQuoteToGraphic</code></a>,
-and
-<a href="/pkg/strconv/#AppendQuoteRuneToGraphic"><code>AppendQuoteRuneToGraphic</code></a>,
-analogous to
-<a href="/pkg/strconv/#QuoteToASCII"><code>QuoteToASCII</code></a>,
-<a href="/pkg/strconv/#QuoteRuneToASCII"><code>QuoteRuneToASCII</code></a>,
-and so on.
-The <code>ASCII</code> family escapes all space characters except ASCII space (U+0020).
-In contrast, the <code>Graphic</code> family does not escape any Unicode space characters (category Zs).
-</li>
-
-<li>
-In the <a href="/pkg/testing/"><code>testing</code></a> package,
-when a test calls
-<a href="/pkg/testing/#T.Parallel">t.Parallel</a>,
-that test is paused until all non-parallel tests complete, and then
-that test continues execution with all other parallel tests.
-Go 1.6 changes the time reported for such a test:
-previously the time counted only the parallel execution,
-but now it also counts the time from the start of testing
-until the call to <code>t.Parallel</code>.
-</li>
-
-<li>
-The <a href="/pkg/text/template/"><code>text/template</code></a> package
-contains two minor changes, in addition to the <a href="#template">major changes</a>
-described above.
-First, it adds a new
-<a href="/pkg/text/template/#ExecError"><code>ExecError</code></a> type
-returned for any error during
-<a href="/pkg/text/template/#Template.Execute"><code>Execute</code></a>
-that does not originate in a <code>Write</code> to the underlying writer.
-Callers can distinguish template usage errors from I/O errors by checking for
-<code>ExecError</code>.
-Second, the
-<a href="/pkg/text/template/#Template.Funcs"><code>Funcs</code></a> method
-now checks that the names used as keys in the
-<a href="/pkg/text/template/#FuncMap"><code>FuncMap</code></a>
-are identifiers that can appear in a template function invocation.
-If not, <code>Funcs</code> panics.
-</li>
-
-<li>
-The <a href="/pkg/time/"><code>time</code></a> package's
-<a href="/pkg/time/#Parse"><code>Parse</code></a> function has always rejected any day of month larger than 31,
-such as January 32.
-In Go 1.6, <code>Parse</code> now also rejects February 29 in non-leap years,
-February 30, February 31, April 31, June 31, September 31, and November 31.
-</li>
-
-</ul>
-
--- a/doc/go1.7.html
+++ b/doc/go1.7.html
--- a/doc/go1.8.html
+++ b/doc/go1.8.html
--- a/doc/go1.9.html
+++ b/doc/go1.9.html
@@ -1,985 +0,0 @@
-<!--{
-	"Title": "Go 1.9 Release Notes",
-	"Path":  "/doc/go1.9",
-	"Template": true
-}-->
-
-<!--
-NOTE: In this document and others in this directory, the convention is to
-set fixed-width phrases with non-fixed-width spaces, as in
-<code>hello</code> <code>world</code>.
-Do not send CLs removing the interior tags from such phrases.
-->
-
-<style>
-ul li { margin: 0.5em 0; }
-</style>
-
-<h2 id="introduction">DRAFT RELEASE NOTES - Introduction to Go 1.9</h2>
-
-<p><strong>
-    Go 1.9 is not yet released. These are work-in-progress
-    release notes. Go 1.9 is expected to be released in August 2017.
-</strong></p>
-
-<p>
-  The latest Go release, version 1.9, arrives six months
-  after <a href="go1.8">Go 1.8</a> and is the tenth release in
-  the <a href="https://golang.org/doc/devel/release.html">Go 1.x
-  series</a>.
-  There are two <a href="#language">changes to the language</a>:
-  adding support for type aliases and defining when implementations
-  may fuse floating point operations.
-  Most of the changes are in the implementation of the toolchain,
-  runtime, and libraries.
-  As always, the release maintains the Go 1
-  <a href="/doc/go1compat.html">promise of compatibility</a>.
-  We expect almost all Go programs to continue to compile and run as
-  before.
-</p>
-
-<p>
-  The release
-  adds <a href="#monotonic-time">transparent monotonic time support</a>,
-  <a href="#parallel-compile">parallelizes compilation of functions</a> within a package,
-  better supports <a href="#test-helper">test helper functions</a>,
-  includes a new <a href="#math-bits">bit manipulation package</a>,
-  and has a new <a href="#sync-map">concurrent map type</a>.
-</p>
-
-<h2 id="language">Changes to the language</h2>
-
-<p>
-  There are two changes to the language.
-</p>
-<p>
-  Go now supports type aliases to support gradual code repair while
-  moving a type between packages.
-  The <a href="https://golang.org/design/18130-type-alias">type alias
-  design document</a>
-  and <a href="https://talks.golang.org/2016/refactor.article">an
-  article on refactoring</a> cover the problem in detail.
-  In short, a type alias declaration has the form:
-</p>
-
-<pre>
-type T1 = T2
-</pre>
-
-<p>
-  This declaration introduces an alias name <code>T1</code>—an
-  alternate spelling—for the type denoted by <code>T2</code>; that is,
-  both <code>T1</code> and <code>T2</code> denote the same type.
-</p>
-
-<p> <!-- CL 40391 -->
-  A smaller language change is that the
-  <a href="/ref/spec#Floating_point_operators">language specification
-  now states</a> when implementations are allowed to fuse floating
-  point operations together, such as by using an architecture's "fused
-  multiply and add" (FMA) instruction to compute <code>x*y</code>&nbsp;<code>+</code>&nbsp;<code>z</code>
-  without rounding the intermediate result <code>x*y</code>.
-  To force the intermediate rounding, write <code>float64(x*y)</code>&nbsp;<code>+</code>&nbsp;<code>z</code>.
-</p>
-
-<h2 id="ports">Ports</h2>
-
-<p>
-  There are no new supported operating systems or processor
-  architectures in this release.
-</p>
-
-<h3 id="power8">ppc64x requires POWER8</h3>
-
-<p> <!-- CL 36725, CL 36832 -->
-  Both <code>GOARCH=ppc64</code> and <code>GOARCH=ppc64le</code> now
-  require at least POWER8 support. In previous releases,
-  only <code>GOARCH=ppc64le</code> required POWER8 and the big
-  endian <code>ppc64</code> architecture supported older
-  hardware.
-<p>
-
-<h3 id="freebsd">FreeBSD</h3>
-
-<p>
-  Go 1.9 is the last release that will run on FreeBSD 9.3,
-  which is already
-  <a href="https://www.freebsd.org/security/unsupported.html">unsupported by FreeBSD</a>.
-  Go 1.10 will require FreeBSD 10.3+.
-</p>
-
-<h3 id="openbsd">OpenBSD 6.0</h3>
-
-<p> <!-- CL 40331 -->
-  Go 1.9 now enables PT_TLS generation for cgo binaries and thus
-  requires OpenBSD 6.0 or newer. Go 1.9 no longer supports
-  OpenBSD 5.9.
-<p>
-
-<h3 id="known_issues">Known Issues</h3>
-
-<p>
-  There are some instabilities on FreeBSD that are known but not understood.
-  These can lead to program crashes in rare cases.
-  See <a href="https://golang.org/issue/15658">issue 15658</a>.
-  Any help in solving this FreeBSD-specific issue would be appreciated.
-</p>
-
-<p>
-  Go stopped running NetBSD builders during the Go 1.9 development
-  cycle due to NetBSD kernel crashes, up to and including NetBSD 7.1.
-  As Go 1.9 is being released, NetBSD 7.1.1 is being released with a fix.
-  However, at this time we have no NetBSD builders passing our test suite.
-  Any help investigating the
-  <a href="https://github.com/golang/go/labels/OS-NetBSD">various NetBSD issues</a>
-  would be appreciated.
-</p>
-
-<h2 id="tools">Tools</h2>
-
-<h3 id="parallel-compile">Parallel Compilation</h3>
-
-<p>
-  The Go compiler now supports compiling a package's functions in parallel, taking
-  advantage of multiple cores. This is in addition to the <code>go</code> command's
-  existing support for parallel compilation of separate packages.
-  Parallel compilation is on by default, but it can be disabled by setting the
-  environment variable <code>GO19CONCURRENTCOMPILATION</code> to <code>0</code>.
-</p>
-
-<h3 id="vendor-dotdotdot">Vendor matching with ./...</h3>
-
-<p><!-- CL 38745 -->
-  By popular request, <code>./...</code> no longer matches packages
-  in <code>vendor</code> directories in tools accepting package names,
-  such as <code>go</code> <code>test</code>. To match vendor
-  directories, write <code>./vendor/...</code>.
-</p>
-
-<h3 id="compiler">Compiler Toolchain</h3>
-
-<p><!-- CL 37441 -->
-  Complex division is now C99-compatible. This has always been the
-  case in gccgo and is now fixed in the gc toolchain.
-</p>
-
-<p> <!-- CL 36983 -->
-  The linker will now generate DWARF information for cgo executables on Windows.
-</p>
-
-<p> <!-- CL 44210, CL 40095 -->
-  The compiler now includes lexical scopes in the generated DWARF if the
-  <code>-N -l</code> flags are provided, allowing
-  debuggers to hide variables that are not in scope. The <code>.debug_info</code>
-  section is now DWARF version 4.
-</p>
-
-<p> <!-- CL 43855 -->
-  The values of <code>GOARM</code> and <code>GO386</code> now affect a
-  compiled package's build ID, as used by the <code>go</code> tool's
-  dependency caching.
-</p>
-
-<h3 id="asm">Assembler</h3>
-
-<p> <!-- CL 42028 -->
-  The four-operand ARM <code>MULA</code> instruction is now assembled correctly,
-  with the addend register as the third argument and the result
-  register as the fourth and final argument.
-  In previous releases, the two meanings were reversed.
-  The three-operand form, in which the fourth argument is implicitly
-  the same as the third, is unaffected.
-  Code using four-operand <code>MULA</code> instructions
-  will need to be updated, but we believe this form is very rarely used.
-  <code>MULAWT</code> and <code>MULAWB</code> were already
-  using the correct order in all forms and are unchanged.
-</p>
-
-<p> <!-- CL 42990 -->
-  The assembler now supports <code>ADDSUBPS/PD</code>, completing the
-  two missing x86 SSE3 instructions.
-</p>
-
-<h3 id="go-doc">Doc</h3>
-
-<p><!-- CL 36031 -->
-  Long lists of arguments are now truncated. This improves the readability
-  of <code>go</code> <code>doc</code> on some generated code.
-</p>
-
-<p><!-- CL 38438 -->
-  Viewing documentation on struct fields is now supported.
-  For example, <code>go</code> <code>doc</code> <code>http.Client.Jar</code>.
-</p>
-
-<h3 id="go-env-json">Env</h3>
-
-<p> <!-- CL 38757 -->
-  The new <code>go</code> <code>env</code> <code>-json</code> flag
-  enables JSON output, instead of the default OS-specific output
-  format.
-</p>
-
-<h3 id="go-test-list">Test</h3>
-
-<p> <!-- CL 41195 -->
-  The <a href="/cmd/go/#hdr-Description_of_testing_flags"><code>go</code> <code>test</code></a>
-  command accepts a new <code>-list</code> flag, which takes a regular
-  expression as an argument and prints to stdout the name of any
-  tests, benchmarks, or examples that match it, without running them.
-</p>
-
-
-<h3 id="go-tool-pprof">Pprof</h3>
-
-<p> <!-- CL 34192 -->
-  Profiles produced by the <code>runtime/pprof</code> package now
-  include symbol information, so they can be viewed
-  in <code>go</code> <code>tool</code> <code>pprof</code>
-  without the binary that produced the profile.
-</p>
-
-<p> <!-- CL 38343 -->
-  The <code>go</code> <code>tool</code> <code>pprof</code> command now
-  uses the HTTP proxy information defined in the environment, using
-  <a href="/pkg/net/http/#ProxyFromEnvironment"><code>http.ProxyFromEnvironment</code></a>.
-</p>
-
-<h3 id="vet">Vet</h3>
-
-<!-- CL 40112 -->
-<p>
-  The <a href="/cmd/vet/"><code>vet</code> command</a>
-  has been better integrated into the
-  <a href="/cmd/go/"><code>go</code> tool</a>,
-  so <code>go</code> <code>vet</code> now supports all standard build
-  flags while <code>vet</code>'s own flags are now available
-  from <code>go</code> <code>vet</code> as well as
-  from <code>go</code> <code>tool</code> <code>vet</code>.
-</p>
-
-<h3 id="gccgo">Gccgo</h3>
-
-<p>
-Due to the alignment of Go's semiannual release schedule with GCC's
-annual release schedule,
-GCC release 7 contains the Go 1.8.3 version of gccgo.
-We expect that the next release, GCC 8, will contain the Go 1.10
-version of gccgo.
-</p>
-
-<h2 id="runtime">Runtime</h2>
-
-<h3 id="callersframes">Call stacks with inlined frames</h3>
-
-<p>
-  Users of
-  <a href="/pkg/runtime#Callers"><code>runtime.Callers</code></a>
-  should avoid directly inspecting the resulting PC slice and instead use
-  <a href="/pkg/runtime#CallersFrames"><code>runtime.CallersFrames</code></a>
-  to get a complete view of the call stack, or
-  <a href="/pkg/runtime#Caller"><code>runtime.Caller</code></a>
-  to get information about a single caller.
-  This is because an individual element of the PC slice cannot account
-  for inlined frames or other nuances of the call stack.
-</p>
-
-<p>
-  Specifically, code that directly iterates over the PC slice and uses
-  functions such as
-  <a href="/pkg/runtime#FuncForPC"><code>runtime.FuncForPC</code></a>
-  to resolve each PC individually will miss inlined frames.
-  To get a complete view of the stack, such code should instead use
-  <code>CallersFrames</code>.
-  Likewise, code should not assume that the length returned by
-  <code>Callers</code> is any indication of the call depth.
-  It should instead count the number of frames returned by
-  <code>CallersFrames</code>.
-</p>
-
-<p>
-  Code that queries a single caller at a specific depth should use
-  <code>Caller</code> rather than passing a slice of length 1 to
-  <code>Callers</code>.
-</p>
-
-<p>
-  <a href="/pkg/runtime#CallersFrames"><code>runtime.CallersFrames</code></a>
-  has been available since Go 1.7, so code can be updated prior to
-  upgrading to Go 1.9.
-</p>
-
-<h2 id="performance">Performance</h2>
-
-<p>
-  As always, the changes are so general and varied that precise
-  statements about performance are difficult to make.  Most programs
-  should run a bit faster, due to speedups in the garbage collector,
-  better generated code, and optimizations in the core library.
-</p>
-
-<h3 id="gc">Garbage Collector</h3>
-
-<p> <!-- CL 37520 -->
-  Library functions that used to trigger stop-the-world garbage
-  collection now trigger concurrent garbage collection.
-
-  Specifically, <a href="/pkg/runtime/#GC"><code>runtime.GC</code></a>,
-  <a href="/pkg/runtime/debug/#SetGCPercent"><code>debug.SetGCPercent</code></a>,
-  and
-  <a href="/pkg/runtime/debug/#FreeOSMemory"><code>debug.FreeOSMemory</code></a>,
-  now trigger concurrent garbage collection, blocking only the calling
-  goroutine until the garbage collection is done.
-</p>
-
-<p> <!-- CL 34103, CL 39835 -->
-  The
-  <a href="/pkg/runtime/debug/#SetGCPercent"><code>debug.SetGCPercent</code></a>
-  function only triggers a garbage collection if one is immediately
-  necessary because of the new GOGC value.
-  This makes it possible to adjust GOGC on-the-fly.
-</p>
-
-<p> <!-- CL 38732 -->
-  Large object allocation performance is significantly improved in
-  applications using large (&gt;50GB) heaps containing many large
-  objects.
-</p>
-
-<p> <!-- CL 34937 -->
-  The <a href="/pkg/runtime/#ReadMemStats"><code>runtime.ReadMemStats</code></a>
-  function now takes less than 100µs even for very large heaps.
-</p>
-
-<h2 id="library">Core library</h2>
-
-<h3 id="monotonic-time">Transparent Monotonic Time support</h3>
-
-<p> <!-- CL 36255 -->
-  The <a href="/pkg/time/"><code>time</code></a> package now transparently
-  tracks monotonic time in each <a href="/pkg/time/#Time"><code>Time</code></a>
-  value, making computing durations between two <code>Time</code> values
-  a safe operation in the presence of wall clock adjustments.
-  See the <a href="/pkg/time/#hdr-Monotonic_Clocks">package docs</a> and
-  <a href="https://golang.org/design/12914-monotonic">design document</a>
-  for details.
-</p>
-
-<h3 id="math-bits">New bit manipulation package</h3>
-
-<p> <!-- CL 36315 -->
-  Go 1.9 includes a new package,
-  <a href="/pkg/math/bits/"><code>math/bits</code></a>, with optimized
-  implementations for manipulating bits. On most architectures,
-  functions in this package are additionally recognized by the
-  compiler and treated as intrinsics for additional performance.
-</p>
-
-<h3 id="test-helper">Test Helper Functions</h3>
-
-<p> <!-- CL 38796 -->
-  The
-  new <a href="/pkg/testing/#T.Helper"><code>(*T).Helper</code></a>
-  and <a href="/pkg/testing/#B.Helper"><code>(*B).Helper</code></a>
-  methods mark the calling function as a test helper function.  When
-  printing file and line information, that function will be skipped.
-  This permits writing test helper functions while still having useful
-  line numbers for users.
-</p>
-
-<h3 id="sync-map">Concurrent Map</h3>
-
-<p> <!-- CL 36617 -->
-  The new <a href="/pkg/sync/#Map"><code>Map</code></a> type
-  in the <a href="/pkg/sync/"><code>sync</code></a> package
-  is a concurrent map with amortized-constant-time loads, stores, and
-  deletes. It is safe for multiple goroutines to call a <code>Map</code>'s methods
-  concurrently.
-</p>
-
-<h3 id="pprof-labels">Profiler Labels</h3>
-
-<p><!-- CL 34198 -->
-  The <a href="/pkg/runtime/pprof"><code>runtime/pprof</code> package</a>
-  now supports adding labels to <code>pprof</code> profiler records.
-  Labels form a key-value map that is used to distinguish calls of the
-  same function in different contexts when looking at profiles
-  with the <a href="/cmd/pprof/"><code>pprof</code> command</a>.
-  The <code>pprof</code> package's
-  new <a href="/pkg/runtime/pprof/#Do"><code>Do</code> function</a>
-  runs code associated with some provided labels. Other new functions
-  in the package help work with labels.
-</p>
-
-</dl><!-- runtime/pprof -->
-
-
-<h3 id="minor_library_changes">Minor changes to the library</h3>
-
-<p>
-  As always, there are various minor changes and updates to the library,
-  made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
-  in mind.
-</p>
-
-<dl id="archive/zip"><dt><a href="/pkg/archive/zip/">archive/zip</a></dt>
-  <dd>
-    <p><!-- CL 39570 -->
-      The
-      ZIP <a href="/pkg/archive/zip/#Writer"><code>Writer</code></a>
-      now sets the UTF-8 bit in
-      the <a href="/pkg/archive/zip/#FileHeader.Flags"><code>FileHeader.Flags</code></a>
-      when appropriate.
-    </p>
-
-</dl><!-- archive/zip -->
-
-<dl id="crypto/rand"><dt><a href="/pkg/crypto/rand/">crypto/rand</a></dt>
-  <dd>
-    <p><!-- CL 43852 -->
-      On Linux, Go now calls the <code>getrandom</code> system call
-      without the <code>GRND_NONBLOCK</code> flag; it will now block
-      until the kernel has sufficient randomness. On kernels predating
-      the <code>getrandom</code> system call, Go continues to read
-      from <code>/dev/urandom</code>.
-    </p>
-
-</dl><!-- crypto/rand -->
-
-<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
-  <dd>
-    <p><!-- CL 36093 -->
-
-      On Unix systems the environment
-      variables <code>SSL_CERT_FILE</code>
-      and <code>SSL_CERT_DIR</code> can now be used to override the
-      system default locations for the SSL certificate file and SSL
-      certificate files directory, respectively.
-    </p>
-
-    <p>The FreeBSD file <code>/usr/local/etc/ssl/cert.pem</code> is
-      now included in the certificate search path.
-    </p>
-
-    <p><!-- CL 36900 -->
-
-      The package now supports excluded domains in name constraints.
-      In addition to enforcing such constraints,
-      <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
-      will create certificates with excluded name constraints
-      if the provided template certificate has the new
-      field
-      <a href="/pkg/crypto/x509/#Certificate.ExcludedDNSDomains"><code>ExcludedDNSDomains</code></a>
-      populated.
-    </p>
-
-</dl><!-- crypto/x509 -->
-
-<dl id="database/sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
-  <dd>
-    <p><!-- CL 35476 -->
-      The package will now use a cached <a href="/pkg/database/sql/#Stmt"><code>Stmt</code></a> if
-      available in <a href="/pkg/database/sql/#Tx.Stmt"><code>Tx.Stmt</code></a>.
-      This prevents statements from being re-prepared each time
-      <a href="/pkg/database/sql/#Tx.Stmt"><code>Tx.Stmt</code></a> is called.
-    </p>
-
-    <p><!-- CL 38533 -->
-      The package now allows drivers to implement their own argument checkers by implementing
-      <a href="/pkg/database/sql/driver/#NamedValueChecker"><code>driver.NamedValueChecker</code></a>.
-      This also allows drivers to support <code>OUTPUT</code> and <code>INOUT</code> parameter types.
-      <a href="/pkg/database/sql/#Out"><code>Out</code></a> should be used to return output parameters
-      when supported by the driver.
-    </p>
-
-    <p><!-- CL 39031 -->
-      <a href="/pkg/database/sql/#Rows.Scan"><code>Rows.Scan</code></a> can now scan user-defined string types.
-      Previously the package supported scanning into numeric types like <code>type</code> <code>Int</code> <code>int64</code>. It now also supports
-      scanning into string types like <code>type</code> <code>String</code> <code>string</code>.
-    </p>
-
-    <p><!-- CL 40694 -->
-      The new <a href="/pkg/database/sql/#DB.Conn"><code>DB.Conn</code></a> method returns the new
-      <a href="/pkg/database/sql/#Conn"><code>Conn</code></a> type representing an
-      exclusive connection to the database from the connection pool. All queries run on
-      a <a href="/pkg/database/sql/#Conn"><code>Conn</code></a> will use the same underlying
-      connection until <a href="/pkg/database/sql/#Conn.Close"><code>Conn.Close</code></a> is called
-      to return the connection to the connection pool.
-    </p>
-
-</dl><!-- database/sql -->
-
-<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
-  <dd>
-    <p><!-- CL 38660 -->
-	  The new
-	  <a href="/pkg/encoding/asn1/#NullBytes"><code>NullBytes</code></a>
-	  and
-	  <a href="/pkg/encoding/asn1/#NullRawValue"><code>NullRawValue</code></a>
-	  represent the ASN.1 NULL type.
-    </p>
-
-</dl><!-- encoding/asn1 -->
-
-<dl id="encoding/base32"><dt><a href="/pkg/encoding/base32/">encoding/base32</a></dt>
-  <dd>
-    <p><!-- CL 38634 -->
-	  The new <a href="/pkg/encoding/base32/#Encoding.WithPadding">Encoding.WithPadding</a>
-	  method adds support for custom padding characters and disabling padding.
-    </p>
-
-</dl><!-- encoding/base32 -->
-
-<dl id="encoding/csv"><dt><a href="/pkg/encoding/csv/">encoding/csv</a></dt>
-  <dd>
-    <p><!-- CL 41730 -->
-      The new field
-      <a href="/pkg/encoding/csv/#Reader.ReuseRecord"><code>Reader.ReuseRecord</code></a>
-      controls whether calls to
-      <a href="/pkg/encoding/csv/#Reader.Read"><code>Read</code></a>
-      may return a slice sharing the backing array of the previous
-      call's returned slice for improved performance.
-    </p>
-
-</dl><!-- encoding/csv -->
-
-<dl id="fmt"><dt><a href="/pkg/fmt/">fmt</a></dt>
-  <dd>
-    <p><!-- CL 37051 -->
-      The sharp flag ('<code>#</code>') is now supported when printing
-      floating point and complex numbers. It will always print a
-      decimal point
-      for <code>%e</code>, <code>%E</code>, <code>%f</code>, <code>%F</code>, <code>%g</code>
-      and <code>%G</code>; it will not remove trailing zeros
-      for <code>%g</code> and <code>%G</code>.
-    </p>
-
-</dl><!-- fmt -->
-
-<dl id="hash/fnv"><dt><a href="/pkg/hash/fnv/">hash/fnv</a></dt>
-  <dd>
-    <p><!-- CL 38356 -->
-      The package now includes 128-bit FNV-1 and FNV-1a hash support with
-      <a href="/pkg/hash/fnv/#New128"><code>New128</code></a> and
-      <a href="/pkg/hash/fnv/#New128a"><code>New128a</code></a>, respectively.
-    </p>
-
-</dl><!-- hash/fnv -->
-
-<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
-  <dd>
-    <p><!-- CL 37880, CL 40936 -->
-	  The package now reports an error if a predefined escaper (one of
-	  "html", "urlquery" and "js") is found in a pipeline and does not match
-	  what the auto-escaper would have decided on its own.
-	  This avoids certain security or correctness issues.
-	  Now use of one of these escapers is always either a no-op or an error.
-	  (The no-op case eases migration from <a href="/pkg/text/template/">text/template</a>.)
-    </p>
-
-</dl><!-- html/template -->
-
-<dl id="image"><dt><a href="/pkg/image/">image</a></dt>
-  <dd>
-    <p><!-- CL 36734 -->
-	  The <a href="/pkg/image/#Rectangle.Intersect"><code>Rectangle.Intersect</code></a>
-	  method now returns a zero <code>Rectangle</code> when called on
-	  adjacent but non-overlapping rectangles, as documented. In
-	  earlier releases it would incorrectly return an empty but
-	  non-zero <code>Rectangle</code>.
-    </p>
-
-</dl><!-- image -->
-
-<dl id="image/color"><dt><a href="/pkg/image/color/">image/color</a></dt>
-  <dd>
-    <p><!-- CL 36732 -->
-	  The YCbCr to RGBA conversion formula has been tweaked to ensure
-	  that rounding adjustments span the complete [0, 0xffff] RGBA
-	  range.
-    </p>
-
-</dl><!-- image/color -->
-
-<dl id="image/png"><dt><a href="/pkg/image/png/">image/png</a></dt>
-  <dd>
-    <p><!-- CL 34150 -->
-	  The new <a href="/pkg/image/png/#Encoder.BufferPool"><code>Encoder.BufferPool</code></a>
-	  field allows specifying an <a href="/pkg/image/png/#EncoderBufferPool"><code>EncoderBufferPool</code></a>,
-	  that will be used by the encoder to get temporary <code>EncoderBuffer</code>
-	  buffers when encoding a PNG image.
-
-	  The use of a <code>BufferPool</code> reduces the number of
-	  memory allocations performed while encoding multiple images.
-    </p>
-
-    <p><!-- CL 38271 -->
-	  The package now supports the decoding of transparent 8-bit
-	  grayscale ("Gray8") images.
-    </p>
-
-</dl><!-- image/png -->
-
-<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
-  <dd>
-    <p><!-- CL 36487 -->
-      The new
-      <a href="/pkg/math/big/#Int.IsInt64"><code>IsInt64</code></a>
-      and
-      <a href="/pkg/math/big/#Int.IsUint64"><code>IsUint64</code></a>
-      methods report whether an <code>Int</code>
-      may be represented as an <code>int64</code> or <code>uint64</code>
-      value.
-    </p>
-
-</dl><!-- math/big -->
-
-<dl id="mime/multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
-  <dd>
-    <p><!-- CL 39223 -->
-      The new
-      <a href="/pkg/mime/multipart/#FileHeader.Size"><code>FileHeader.Size</code></a>
-      field describes the size of a file in a multipart message.
-    </p>
-
-</dl><!-- mime/multipart -->
-
-<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
-  <dd>
-    <p><!-- CL 32572 -->
-      The new
-      <a href="/pkg/net/#Resolver.StrictErrors"><code>Resolver.StrictErrors</code></a>
-      provides control over how Go's built-in DNS resolver handles
-      temporary errors during queries composed of multiple sub-queries,
-      such as an A+AAAA address lookup.
-    </p>
-
-    <p><!-- CL 37260 -->
-      The new
-      <a href="/pkg/net/#Resolver.Dial"><code>Resolver.Dial</code></a>
-      allows a <code>Resolver</code> to use a custom dial function.
-    </p>
-
-    <p><!-- CL 40510 -->
-      <a href="/pkg/net/#JoinHostPort"><code>JoinHostPort</code></a> now only places an address in square brackets if the host contains a colon.
-      In previous releases it would also wrap addresses in square brackets if they contained a percent ('<code>%</code>') sign.
-    </p>
-
-    <p><!-- CL 37913 -->
-      The new methods
-      <a href="/pkg/net/#TCPConn.SyscallConn"><code>TCPConn.SyscallConn</code></a>,
-      <a href="/pkg/net/#IPConn.SyscallConn"><code>IPConn.SyscallConn</code></a>,
-      <a href="/pkg/net/#UDPConn.SyscallConn"><code>UDPConn.SyscallConn</code></a>,
-      and
-      <a href="/pkg/net/#UnixConn.SyscallConn"><code>UnixConn.SyscallConn</code></a>
-      provide access to the connections' underlying file descriptors.
-    </p>
-
-    <p><!-- 45088 -->
-      It is now safe to call <a href="/pkg/net/#Dial"><code>Dial</code></a> with the address obtained from
-      <code>(*TCPListener).String()</code> after creating the listener with
-      <code><a href="/pkg/net/#Listen">Listen</a>("tcp", ":0")</code>.
-      Previously it failed on some machines with half-configured IPv6 stacks.
-    </p>
-
-</dl><!-- net -->
-
-<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
-  <dd>
-
-    <p><!-- CL 37328 -->
-      The <a href="/pkg/net/http/#Cookie.String"><code>Cookie.String</code></a> method, used for
-      <code>Cookie</code> and <code>Set-Cookie</code> headers, now encloses values in double quotes
-      if the value contains either a space or a comma.
-    </p>
-
-    <p>Server changes:</p>
-    <ul>
-      <li><!-- CL 38194 -->
-        <a href="/pkg/net/http/#ServeMux"><code>ServeMux</code></a> now ignores ports in the host
-        header when matching handlers. The host is matched unmodified for <code>CONNECT</code> requests.
-      </li>
-
-      <li><!-- CL 34727 -->
-        <a href="/pkg/net/http/#Server.WriteTimeout"><code>Server.WriteTimeout</code></a>
-        now applies to HTTP/2 connections and is enforced per-stream.
-      </li>
-
-      <li><!-- CL 43231 -->
-        HTTP/2 now uses the priority write scheduler by default.
-        Frames are scheduled by following HTTP/2 priorities as described in
-        <a href="https://tools.ietf.org/html/rfc7540#section-5.3">RFC 7540 Section 5.3</a>.
-      </li>
-
-      <li><!-- CL 36483 -->
-        The HTTP handler returned by <a href="/pkg/net/http/#StripPrefix"><code>StripPrefix</code></a>
-        now calls its provided handler with a modified clone of the original <code>*http.Request</code>.
-        Any code storing per-request state in maps keyed by <code>*http.Request</code> should
-        use
-        <a href="/pkg/net/http/#Request.Context"><code>Request.Context</code></a>,
-        <a href="/pkg/net/http/#Request.WithContext"><code>Request.WithContext</code></a>,
-        and
-        <a href="/pkg/context/#WithValue"><code>context.WithValue</code></a> instead.
-      </li>
-    </ul>
-
-    <p>Client &amp; Transport changes:</p>
-    <ul>
-      <li><!-- CL 35488 -->
-        The <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
-        now supports making requests via SOCKS5 proxy when the URL returned by
-        <a href="/net/http/#Transport.Proxy"><code>Transport.Proxy</code></a>
-        has the scheme <code>socks5</code>.
-      </li>
-    </ul>
-
-</dl><!-- net/http -->
-
-<dl id="net/http/fcgi"><dt><a href="/pkg/net/http/fcgi/">net/http/fcgi</a></dt>
-  <dd>
-    <p><!-- CL 40012 -->
-      The new
-      <a href="/pkg/net/http/fcgi/#ProcessEnv"><code>ProcessEnv</code></a>
-      function returns FastCGI environment variables associated with an HTTP request
-      for which there are no appropriate
-      <a href="/pkg/net/http/#Request"><code>http.Request</code></a>
-      fields, such as <code>REMOTE_USER</code>.
-    </p>
-
-</dl><!-- net/http/fcgi -->
-
-<dl id="net/http/httptest"><dt><a href="/pkg/net/http/httptest/">net/http/httptest</a></dt>
-  <dd>
-    <p><!-- CL 34639 -->
-      The new
-      <a href="/pkg/net/http/httptest/#Server.Client"><code>Server.Client</code></a>
-      method returns an HTTP client configured for making requests to the test server.
-    </p>
-
-    <p>
-      The new
-      <a href="/pkg/net/http/httptest/#Server.Certificate"><code>Server.Certificate</code></a>
-      method returns the test server's TLS certificate, if any.
-    </p>
-
-</dl><!-- net/http/httptest -->
-
-<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
-  <dd>
-    <p><!-- CL 36800 -->
-      The <code>os</code> package now uses the internal runtime poller
-      for file I/O.
-      This reduces the number of threads required for read/write
-      operations on pipes, and it eliminates races when one goroutine
-      closes a file while another is using the file for I/O.
-    </p>
-
-  <dd>
-    <p><!-- CL 37915 -->
-      On Windows,
-      <a href="/pkg/os/#Args"><code>Args</code></a>
-      is now populated without <code>shell32.dll</code>, improving process start-up time by 1-7 ms.
-      </p>
-
-</dl><!-- os -->
-
-<dl id="os/exec"><dt><a href="/pkg/os/exec/">os/exec</a></dt>
-  <dd>
-    <p><!-- CL 37586 -->
-      The <code>os/exec</code> package now prevents child processes from being created with
-      any duplicate environment variables.
-      If <a href="/pkg/os/exec/#Cmd.Env"><code>Cmd.Env</code></a>
-      contains duplicate environment keys, only the last
-      value in the slice for each duplicate key is used.
-    </p>
-
-</dl><!-- os/exec -->
-
-<dl id="os/user"><dt><a href="/pkg/os/user/">os/user</a></dt>
-  <dd>
-    <p><!-- CL 37664 -->
-      <a href="/pkg/os/user/#Lookup"><code>Lookup</code></a> and
-      <a href="/pkg/os/user/#LookupId"><code>LookupId</code></a> now
-      work on Unix systems when <code>CGO_ENABLED=0</code> by reading
-      the <code>/etc/passwd</code> file.
-    </p>
-
-    <p><!-- CL 33713 -->
-      <a href="/pkg/os/user/#LookupGroup"><code>LookupGroup</code></a> and
-      <a href="/pkg/os/user/#LookupGroupId"><code>LookupGroupId</code></a> now
-      work on Unix systems when <code>CGO_ENABLED=0</code> by reading
-      the <code>/etc/group</code> file.
-    </p>
-
-</dl><!-- os/user -->
-
-<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
-  <dd>
-    <p><!-- CL 38335 -->
-      The new
-      <a href="/pkg/reflect/#MakeMapWithSize"><code>MakeMapWithSize</code></a>
-      function creates a map with a capacity hint.
-    </p>
-
-</dl><!-- reflect -->
-
-<dl id="runtime"><dt><a href="/pkg/runtime/">runtime</a></dt>
-  <dd>
-    <p><!-- CL 37233, CL 37726 -->
-      Tracebacks generated by the runtime and recorded in profiles are
-      now accurate in the presence of inlining.
-      To retrieve tracebacks programmatically, applications should use
-      <a href="/pkg/runtime/#CallersFrames"><code>runtime.CallersFrames</code></a>
-      rather than directly iterating over the results of
-      <a href="/pkg/runtime/#Callers"><code>runtime.Callers</code></a>.
-    </p>
-
-    <p><!-- CL 38403 -->
-      On Windows, Go no longer forces the system timer to run at high
-      resolution when the program is idle.
-      This should reduce the impact of Go programs on battery life.
-    </p>
-
-    <p><!-- CL 29341 -->
-      On FreeBSD, <code>GOMAXPROCS</code> and
-      <a href="/pkg/runtime/#NumCPU"><code>runtime.NumCPU</code></a>
-      are now based on the process' CPU mask, rather than the total
-      number of CPUs.
-    </p>
-
-    <p><!-- CL 43641 -->
-      The runtime has preliminary support for Android O.
-    </p>
-
-</dl><!-- runtime -->
-
-<dl id="runtime/debug"><dt><a href="/pkg/runtime/debug/">runtime/debug</a></dt>
-  <dd>
-    <p><!-- CL 34013 -->
-      Calling
-      <a href="/pkg/runtime/debug/#SetGCPercent"><code>SetGCPercent</code></a>
-      with a negative value no longer runs an immediate garbage collection.
-    </p>
-
-</dl><!-- runtime/debug -->
-
-<dl id="runtime/trace"><dt><a href="/pkg/runtime/trace/">runtime/trace</a></dt>
-  <dd>
-    <p><!-- CL 36015 -->
-      The execution trace now displays mark assist events, which
-      indicate when an application goroutine is forced to assist
-      garbage collection because it is allocating too quickly.
-    </p>
-
-    <p><!-- CL 40810 -->
-      "Sweep" events now encompass the entire process of finding free
-      space for an allocation, rather than recording each individual
-      span that is swept.
-      This reduces allocation latency when tracing allocation-heavy
-      programs.
-      The sweep event shows how many bytes were swept and how many
-      were reclaimed.
-    </p>
-
-</dl><!-- runtime/trace -->
-
-<dl id="sync"><dt><a href="/pkg/sync/">sync</a></dt>
-  <dd>
-    <p><!-- CL 34310 -->
-      <a href="/pkg/sync/#Mutex"><code>Mutex</code></a> is now more fair.
-    </p>
-
-</dl><!-- sync -->
-
-<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
-  <dd>
-    <p><!-- CL 36697 -->
-      The new field
-      <a href="/pkg/syscall/#Credential.NoSetGroups"><code>Credential.NoSetGroups</code></a>
-      controls whether Unix systems make a <code>setgroups</code> system call
-      to set supplementary groups when starting a new process.
-    </p>
-
-    <p><!-- CL 43512 -->
-      The new field
-      <a href="/pkg/syscall/#SysProcAttr.AmbientCaps"><code>SysProcAttr.AmbientCaps</code></a>
-      allows setting ambient capabilities on Linux 4.3+ when creating
-      a new process.
-    </p>
-
-    <p><!-- CL 37439 -->
-      On 64-bit x86 Linux, process creation latency has been optimized with
-      use of <code>CLONE_VFORK</code> and <code>CLONE_VM</code>.
-    </p>
-
-    <p><!-- CL 37913 -->
-      The new
-      <a href="/pkg/syscall/#Conn"><code>Conn</code></a>
-      interface describes some types in the
-      <a href="/pkg/net/"><code>net</code></a>
-      package that can provide access to their underlying file descriptor
-      using the new
-      <a href="/pkg/syscall/#RawConn"><code>RawConn</code></a>
-      interface.
-    </p>
-
-</dl><!-- syscall -->
-
-
-<dl id="testing/quick"><dt><a href="/pkg/testing/quick/">testing/quick</a></dt>
-  <dd>
-    <p><!-- CL 39152 -->
-      The package now chooses values in the full range when
-      generating <code>int64</code> and <code>uint64</code> random
-      numbers; in earlier releases generated values were always
-      limited to the [-2<sup>62</sup>, 2<sup>62</sup>) range.
-    </p>
-
-    <p>
-      In previous releases, using a nil
-      <a href="/pkg/testing/quick/#Config.Rand"><code>Config.Rand</code></a>
-      value caused a fixed deterministic random number generator to be used.
-      It now uses a random number generator seeded with the current time.
-      For the old behavior, set <code>Config.Rand</code> to <code>rand.New(rand.NewSource(0))</code>.
-    </p>
-
-</dl><!-- testing/quick -->
-
-<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
-  <dd>
-    <p><!-- CL 38420 -->
-	  The handling of empty blocks, which was broken by a Go 1.8
-	  change that made the result dependent on the order of templates,
-	  has been fixed, restoring the old Go 1.7 behavior.
-    </p>
-
-</dl><!-- text/template -->
-
-<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
-  <dd>
-    <p><!-- CL 36615 -->
-      The new methods
-      <a href="/pkg/time/#Duration.Round"><code>Duration.Round</code></a>
-      and
-      <a href="/pkg/time/#Duration.Truncate"><code>Duration.Truncate</code></a>
-      handle rounding and truncating durations to multiples of a given duration.
-    </p>
-
-    <p><!-- CL 35710 -->
-      Retrieving the time and sleeping now work correctly under Wine.
-    </p>
-
-    <p>
-      If a <code>Time</code> value has a monotonic clock reading, its
-      string representation (as returned by <code>String</code>) now includes a
-      final field <code>"m=±value"</code>, where <code>value</code> is the
-      monotonic clock reading formatted as a decimal number of seconds.
-    </p>
-
-    <p><!-- CL 44832 -->
-      The included <code>tzdata</code> timezone database has been
-      updated to version 2017b. As always, it is only used if the
-      system does not already have the database available.
-    </p>
-
-</dl><!-- time -->
--- a/doc/go1compat.html
+++ b/doc/go1compat.html
@@ -95,18 +95,6 @@ We therefore recommend that composite literals whose type is defined
 in a separate package should use the keyed notation.
 </li>

-<li>
-Methods. As with struct fields, it may be necessary to add methods
-to types.
-Under some circumstances, such as when the type is embedded in
-a struct along with another type,
-the addition of the new method may break
-the struct by creating a conflict with an existing method of the other
-embedded type.
-We cannot protect against this rare case and do not guarantee compatibility
-should it arise.
-</li>
-
 <li>
 Dot imports. If a program imports a standard package
 using <code>import . "path"</code>, additional names defined in the
--- a/doc/go_faq.html
+++ b/doc/go_faq.html
@@ -92,16 +92,22 @@ portability and the addition of new functionality such as improved support for i
 There may well be a Go 2 one day, but not for a few years and it will be influenced by what we learn using Go 1 as it is today.
 </p>

+<h3 id="What_is_the_origin_of_the_name">
+What is the origin of the name?</h3>
+
+<p>
+&ldquo;Ogle&rdquo; would be a good name for a Go debugger.
+</p>
+
 <h3 id="Whats_the_origin_of_the_mascot">
 What's the origin of the mascot?</h3>

 <p>
 The mascot and logo were designed by
 <a href="http://reneefrench.blogspot.com">Renée French</a>, who also designed
-<a href="https://9p.io/plan9/glenda.html">Glenda</a>,
+<a href="http://plan9.bell-labs.com/plan9/glenda.html">Glenda</a>,
 the Plan 9 bunny.
-The <a href="https://blog.golang.org/gopher">gopher</a>
-is derived from one she used for an <a href="http://wfmu.org/">WFMU</a>
+The gopher is derived from one she used for an <a href="http://wfmu.org/">WFMU</a>
 T-shirt design some years ago.
 The logo and mascot are covered by the
 <a href="http://creativecommons.org/licenses/by/3.0/">Creative Commons Attribution 3.0</a>
@@ -147,7 +153,7 @@ Go is an attempt to combine the ease of programming of an interpreted,
 dynamically typed
 language with the efficiency and safety of a statically typed, compiled language.
 It also aims to be modern, with support for networked and multicore
-computing.  Finally, working with Go is intended to be <i>fast</i>: it should take
+computing.  Finally, it is intended to be <i>fast</i>: it should take
 at most a few seconds to build a large executable on a single computer.
 To meet these goals required addressing a number of
 linguistic issues: an expressive but lightweight type system;
@@ -222,7 +228,7 @@ document server running in a production configuration on
 </p>

 <p>
-Other examples include the <a href="//github.com/youtube/vitess/">Vitess</a>
+Other examples include the <a href="https://code.google.com/p/vitess/">Vitess</a>
 system for large-scale SQL installations and Google's download server, <code>dl.google.com</code>,
 which delivers Chrome binaries and other large installables such as <code>apt-get</code>
 packages.
@@ -233,7 +239,7 @@ Do Go programs link with C/C++ programs?</h3>

 <p>
 There are two Go compiler implementations, <code>gc</code>
-and <code>gccgo</code>.
+(the <code>6g</code> program and friends) and <code>gccgo</code>.
 <code>Gc</code> uses a different calling convention and linker and can
 therefore only be linked with C programs using the same convention.
 There is such a C compiler but no C++ compiler.
@@ -254,7 +260,7 @@ Does Go support Google's protocol buffers?</h3>
 <p>
 A separate open source project provides the necessary compiler plugin and library.
 It is available at
-<a href="//github.com/golang/protobuf">github.com/golang/protobuf/</a>
+<a href="//code.google.com/p/goprotobuf/">code.google.com/p/goprotobuf/</a>
 </p>


@@ -271,27 +277,6 @@ you will need to abide by the guidelines at

 <h2 id="Design">Design</h2>

-<h3 id="runtime">
-Does Go have a runtime?</h3>
-
-<p>
-Go does have an extensive library, called the <em>runtime</em>,
-that is part of every Go program.
-The runtime library implements garbage collection, concurrency,
-stack management, and other critical features of the Go language.
-Although it is more central to the language, Go's runtime is analogous
-to <code>libc</code>, the C library.
-</p>
-
-<p>
-It is important to understand, however, that Go's runtime does not
-include a virtual machine, such as is provided by the Java runtime.
-Go programs are compiled ahead of time to native machine code.
-Thus, although the term is often used to describe the virtual
-environment in which a program runs, in Go the word &ldquo;runtime&rdquo;
-is just the name given to the library providing critical language services.
-</p>
-
 <h3 id="unicode_identifiers">
 What's up with Unicode identifiers?</h3>

@@ -356,10 +341,7 @@ code that does what generics would enable, if less smoothly.
 </p>

 <p>
-The topic remains open.
-For a look at several previous unsuccessful attempts to
-design a good generics solution for Go, see
-<a href="https://golang.org/issue/15292">this proposal</a>.
+This remains an open issue.
 </p>

 <h3 id="exceptions">
@@ -526,7 +508,7 @@ They are not restricted to structs (classes).
 </p>

 <p>
-Also, the lack of a type hierarchy makes &ldquo;objects&rdquo; in Go feel much more
+Also, the lack of type hierarchy makes &ldquo;objects&rdquo; in Go feel much more
 lightweight than in languages such as C++ or Java.
 </p>

@@ -626,19 +608,17 @@ How can I guarantee my type satisfies an interface?</h3>

 <p>
 You can ask the compiler to check that the type <code>T</code> implements the
-interface <code>I</code> by attempting an assignment using the zero value for
-<code>T</code> or pointer to <code>T</code>, as appropriate:
+interface <code>I</code> by attempting an assignment:
 </p>

 <pre>
 type T struct{}
-var _ I = T{}       // Verify that T implements I.
-var _ I = (*T)(nil) // Verify that *T implements I.
+var _ I = T{}   // Verify that T implements I.
 </pre>

 <p>
-If <code>T</code> (or <code>*T</code>, accordingly) doesn't implement
-<code>I</code>, the mistake will be caught at compile time.
+If <code>T</code> doesn't implement <code>I</code>, the mistake will be caught
+at compile time.
 </p>

 <p>
@@ -746,7 +726,7 @@ interface satisfaction very easy to state: are the function's names
 and signatures exactly those of the interface?
 Go's rule is also easy to implement efficiently.
 We feel these benefits offset the lack of
-automatic type promotion. Should Go one day adopt some form of polymorphic
+automatic type promotion. Should Go one day adopt some form of generic
 typing, we expect there would be a way to express the idea of these
 examples and also have them be statically checked.
 </p>
@@ -769,29 +749,6 @@ for i, v := range t {
 }
 </pre>

-<h3 id="convert_slice_with_same_underlying_type">
-Can I convert []T1 to []T2 if T1 and T2 have the same underlying type?</h3>
-
-This last line of this code sample does not compile.
-
-<pre>
-type T1 int
-type T2 int
-var t1 T1
-var x = T2(t1) // OK
-var st1 []T1
-var sx = ([]T2)(st1) // NOT OK
-</pre>
-
-<p>
-In Go, types are closely tied to methods, in that every named type has
-a (possibly empty) method set.
-The general rule is that you can change the name of the type being
-converted (and thus possibly change its method set) but you can't
-change the name (and method set) of elements of a composite type.
-Go requires you to be explicit about type conversions.
-</p>
-
 <h3 id="nil_error">
 Why is my nil error value not equal to nil?
 </h3>
@@ -808,7 +765,7 @@ schematically, (<code>int</code>, <code>3</code>).
 An interface value is <code>nil</code> only if the inner value and type are both unset,
 (<code>nil</code>, <code>nil</code>).
 In particular, a <code>nil</code> interface will always hold a <code>nil</code> type.
-If we store a <code>nil</code> pointer of type <code>*int</code> inside
+If we store a pointer of type <code>*int</code> inside
 an interface value, the inner type will be <code>*int</code> regardless of the value of the pointer:
 (<code>*int</code>, <code>nil</code>).
 Such an interface value will therefore be non-<code>nil</code>
@@ -816,7 +773,7 @@ Such an interface value will therefore be non-<code>nil</code>
 </p>

 <p>
-This situation can be confusing, and arises when a <code>nil</code> value is
+This situation can be confusing, and often arises when a <code>nil</code> value is
 stored inside an interface value such as an <code>error</code> return:
 </p>

@@ -907,39 +864,6 @@ value to hold the error and a type switch to discriminate cases.  The
 syntax tree example is also doable, although not as elegantly.
 </p>

-<h3 id="covariant_types">
-Why does Go not have covariant result types?</h3>
-
-<p>
-Covariant result types would mean that an interface like
-</p>
-
-<pre>
-type Copyable interface {
-	Copy() interface{}
-}
-</pre>
-
-<p>
-would be satisfied by the method
-</p>
-
-<pre>
-func (v Value) Copy() Value
-</pre>
-
-<p>because <code>Value</code> implements the empty interface.
-In Go method types must match exactly, so <code>Value</code> does not
-implement <code>Copyable</code>.
-Go separates the notion of what a
-type does&mdash;its methods&mdash;from the type's implementation.
-If two methods return different types, they are not doing the same thing.
-Programmers who want covariant result types are often trying to
-express a type hierarchy through interfaces.
-In Go it's more natural to have a clean separation between interface
-and implementation.
-</p>
-
 <h2 id="values">Values</h2>

 <h3 id="conversions">
@@ -966,7 +890,7 @@ encourages you to be explicit.
 </p>

 <p>
-A blog post titled <a href="https://blog.golang.org/constants">Constants</a>
+A blog post, title <a href="http://blog.golang.org/constants">Constants</a>,
 explores this topic in more detail.
 </p>

@@ -1026,19 +950,6 @@ In fact, <code>godoc</code> implements the full site at
 <a href="/">golang.org/</a>.
 </p>

-<p>
-A <code>godoc</code> instance may be configured to provide rich,
-interactive static analyses of symbols in the programs it displays; details are
-listed <a href="https://golang.org/lib/godoc/analysis/help.html">here</a>.
-</p>
-
-<p>
-For access to documentation from the command line, the
-<a href="https://golang.org/pkg/cmd/go/">go</a> tool has a
-<a href="https://golang.org/pkg/cmd/go/#hdr-Show_documentation_for_package_or_symbol">doc</a>
-subcommand that provides a textual interface to the same information.
-</p>
-
 <h3 id="Is_there_a_Go_programming_style_guide">
 Is there a Go programming style guide?</h3>

@@ -1075,6 +986,32 @@ See the document
 for more information about how to proceed.
 </p>

+<h3 id="Why_does_the_project_use_Mercurial_and_not_git">
+Why does the project use Mercurial and not git?</h3>
+
+<p>
+The Go project, hosted by Google Code at
+<a href="//code.google.com/p/go">code.google.com/p/go</a>,
+uses Mercurial as its version control system.
+When the project launched,
+Google Code supported only Subversion and Mercurial.
+Mercurial was a better choice because of its plugin mechanism
+that allowed us to create the "codereview" plugin to connect
+the project to the excellent code review tools at
+<a href="//codereview.appspot.com">codereview.appspot.com</a>.
+</p>
+
+<p>
+Programmers who work
+with the Go project's source rather than release downloads sometimes
+ask for the project to switch to git.
+That would be possible, but it would be a lot of work and
+would also require reimplementing the codereview plugin.
+Given that Mercurial works today, with code review support,
+combined with the Go project's mostly linear, non-branching use of
+version control, a switch to git doesn't seem worthwhile.
+</p>
+
 <h3 id="git_https">
 Why does "go get" use HTTPS when cloning a repository?</h3>

@@ -1094,7 +1031,7 @@ it's easy to work around this. For GitHub, try one of these solutions:
 <ul>
 <li>Manually clone the repository in the expected package directory:
 <pre>
-$ cd src/github.com/username
+$ cd $GOPATH/src/github.com/username
 $ git clone git@github.com:username/package.git
 </pre>
 </li>
@@ -1135,24 +1072,7 @@ unexpected ways, the simplest solution is to copy it to your local repository.
 (This is the approach Google takes internally.)
 Store the copy under a new import path that identifies it as a local copy.
 For example, you might copy "original.com/pkg" to "you.com/external/original.com/pkg".
-The <a href="https://godoc.org/golang.org/x/tools/cmd/gomvpkg">gomvpkg</a>
-program is one tool to help automate this process.
-</p>
-
-<p>
-The Go 1.5 release added a facility to the
-<a href="https://golang.org/cmd/go">go</a> command
-that makes it easier to manage external dependencies by "vendoring"
-them into a special directory near the package that depends upon them.
-See the <a href="https://golang.org/s/go15vendor">design
-document</a> for details.
-</p>
-
-<p>
-Work is underway on an experimental package management tool,
-<a href="https://github.com/golang/dep"><code>dep</code></a>, to learn
-more about how tooling can help package management. More information can be found in
-<a href="https://github.com/golang/dep/blob/master/FAQ.md">the <code>dep</code> FAQ</a>.
+Keith Rarick's <a href="https://github.com/kr/goven">goven</a> is one tool to help automate this process.
 </p>

 <h2 id="Pointers">Pointers and Allocation</h2>
@@ -1167,8 +1087,7 @@ thing being passed, as if there were an assignment statement assigning the
 value to the parameter.  For instance, passing an <code>int</code> value
 to a function makes a copy of the <code>int</code>, and passing a pointer
 value makes a copy of the pointer, but not the data it points to.
-(See a <a href="/doc/faq#methods_on_values_or_pointers">later
-section</a> for a discussion of how this affects method receivers.)
+(See the next section for a discussion of how this affects method receivers.)
 </p>

 <p>
@@ -1181,12 +1100,6 @@ struct.  If the interface value holds a pointer, copying the interface value
 makes a copy of the pointer, but again not the data it points to.
 </p>

-<p>
-Note that this discussion is about the semantics of the operations.
-Actual implementations may apply optimizations to avoid copying
-as long as the optimizations do not change the semantics.
-</p>
-
 <h3 id="pointer_to_interface">
 When should I use a pointer to an interface?</h3>

@@ -1322,26 +1235,11 @@ size of value should use an explicitly sized type, like <code>int64</code>.
 Prior to Go 1.1, the 64-bit Go compilers (both gc and gccgo) used
 a 32-bit representation for <code>int</code>. As of Go 1.1 they use
 a 64-bit representation.
-</p>
-
-<p>
 On the other hand, floating-point scalars and complex
-types are always sized (there are no <code>float</code> or <code>complex</code> basic types),
-because programmers should be aware of precision when using floating-point numbers.
-The default type used for an (untyped) floating-point constant is <code>float64</code>.
-Thus <code>foo</code> <code>:=</code> <code>3.0</code> declares a variable <code>foo</code>
-of type <code>float64</code>.
-For a <code>float32</code> variable initialized by an (untyped) constant, the variable type
-must be specified explicitly in the variable declaration:
-</p>
-
-<pre>
-var foo float32 = 3.0
-</pre>
-
-<p>
-Alternatively, the constant must be given a type with a conversion as in
-<code>foo := float32(3.0)</code>.
+numbers are always sized: <code>float32</code>, <code>complex64</code>,
+etc., because programmers should be aware of precision when using
+floating-point numbers.
+The default size of a floating-point constant is <code>float64</code>.
 </p>

 <h3 id="stack_or_heap">
@@ -1418,20 +1316,14 @@ See the <a href="/doc/codewalk/sharemem/">Share Memory By Communicating</a> code
 Why doesn't my multi-goroutine program use multiple CPUs?</h3>

 <p>
-The number of CPUs available simultaneously to executing goroutines is
-controlled by the <code>GOMAXPROCS</code> shell environment variable.
-In earlier releases of Go, the default value was 1, but as of Go 1.5 the default
-value is the number of cores available.
-Therefore programs compiled after 1.5 should demonstrate parallel execution
-of multiple goroutines.
-To change the behavior, set the environment variable or use the similarly-named
-<a href="/pkg/runtime/#GOMAXPROCS">function</a>
-of the runtime package to configure the
-run-time support to utilize a different number of threads.
+You must set the <code>GOMAXPROCS</code> shell environment variable
+or use the similarly-named <a href="/pkg/runtime/#GOMAXPROCS"><code>function</code></a>
+of the runtime package to allow the
+run-time support to utilize more than one OS thread.
 </p>

 <p>
-Programs that perform parallel computation might benefit from a further increase in
+Programs that perform parallel computation should benefit from an increase in
 <code>GOMAXPROCS</code>.
 However, be aware that
 <a href="//blog.golang.org/2013/01/concurrency-is-not-parallelism.html">concurrency
@@ -1453,7 +1345,7 @@ intrinsically parallel.
 <p>
 In practical terms, programs that spend more time
 communicating on channels than doing computation
-may experience performance degradation when using
+will experience performance degradation when using
 multiple OS threads.
 This is because sending data between threads involves switching
 contexts, which has significant cost.
@@ -1464,11 +1356,9 @@ to speed it up.
 </p>

 <p>
-Go's goroutine scheduler is not as good as it needs to be, although it
-has improved in recent releases.
-In the future, it may better optimize its use of OS threads.
-For now, if there are performance issues,
-setting <code>GOMAXPROCS</code> on a per-application basis may help.
+Go's goroutine scheduler is not as good as it needs to be. In the future, it
+should recognize such cases and optimize its use of OS threads. For now,
+<code>GOMAXPROCS</code> should be set on a per-application basis.
 </p>

 <p>
@@ -1503,10 +1393,7 @@ there is no useful way for a method call to obtain a pointer.
 Even in cases where the compiler could take the address of a value
 to pass to the method, if the method modifies the value the changes
 will be lost in the caller.
-As an example, if the <code>Write</code> method of
-<a href="/pkg/bytes/#Buffer"><code>bytes.Buffer</code></a>
-used a value receiver rather than a pointer,
-this code:
+As a common example, this code:
 </p>

 <pre>
@@ -1600,7 +1487,7 @@ seem odd but works fine in Go:
 Does Go have the <code>?:</code> operator?</h3>

 <p>
-There is no ternary testing operation in Go. You may use the following to achieve the same
+There is no ternary form in Go. You may use the following to achieve the same
 result:
 </p>

@@ -1692,51 +1579,6 @@ test cases. The standard Go library is full of illustrative examples, such as in
 <a href="/src/fmt/fmt_test.go">the formatting tests for the <code>fmt</code> package</a>.
 </p>

-<h3 id="x_in_std">
-Why isn't <i>X</i> in the standard library?</h3>
-
-<p>
-The standard library's purpose is to support the runtime, connect to
-the operating system, and provide key functionality that many Go
-programs require, such as formatted I/O and networking.
-It also contains elements important for web programming, including
-cryptography and support for standards like HTTP, JSON, and XML.
-</p>
-
-<p>
-There is no clear criterion that defines what is included because for
-a long time, this was the <i>only</i> Go library.
-There are criteria that define what gets added today, however.
-</p>
-
-<p>
-New additions to the standard library are rare and the bar for
-inclusion is high.
-Code included in the standard library bears a large ongoing maintenance cost
-(often borne by those other than the original author),
-is subject to the <a href="/doc/go1compat.html">Go 1 compatibility promise</a>
-(blocking fixes to any flaws in the API),
-and is subject to the Go
-<a href="https://golang.org/s/releasesched">release schedule</a>,
-preventing bug fixes from being available to users quickly.
-</p>
-
-<p>
-Most new code should live outside of the standard library and be accessible
-via the <a href="/cmd/go/"><code>go</code> tool</a>'s
-<code>go get</code> command.
-Such code can have its own maintainers, release cycle,
-and compatibility guarantees.
-Users can find packages and read their documentation at
-<a href="https://godoc.org/">godoc.org</a>.
-</p>
-
-<p>
-Although there are pieces in the standard library that don't really belong,
-such as <code>log/syslog</code>, we continue to maintain everything in the
-library because of the Go 1 compatibility promise.
-But we encourage most new code to live elsewhere.
-</p>

 <h2 id="Implementation">Implementation</h2>

@@ -1745,9 +1587,11 @@ What compiler technology is used to build the compilers?</h3>

 <p>
 <code>Gccgo</code> has a front end written in C++, with a recursive descent parser coupled to the
-standard GCC back end. <code>Gc</code> is written in Go with a recursive descent parser
-and uses a custom loader, also written in Go but
-based on the Plan 9 loader, to generate ELF/Mach-O/PE binaries.
+standard GCC back end. <code>Gc</code> is written in C using
+<code>yacc</code>/<code>bison</code> for the parser.
+Although it's a new program, it fits in the Plan 9 C compiler suite
+(<a href="http://plan9.bell-labs.com/sys/doc/compiler.html">http://plan9.bell-labs.com/sys/doc/compiler.html</a>)
+and uses a variant of the Plan 9 loader to generate ELF/Mach-O/PE binaries.
 </p>

 <p>
@@ -1756,26 +1600,24 @@ slow to meet our performance goals.
 </p>

 <p>
-The original <code>gc</code>, the Go compiler, was written in C
-because of the difficulties of bootstrapping&mdash;you'd need a Go compiler to
-set up a Go environment.
-But things have advanced and as of Go 1.5 the compiler is written in Go.
-It was converted from C to Go using automatic translation tools, as
-described in <a href="/s/go13compiler">this design document</a>
-and <a href="https://talks.golang.org/2015/gogo.slide#1">a recent talk</a>.
-Thus the compiler is now "self-hosting", which means we must face
-the bootstrapping problem.
-The solution, naturally, is to have a working Go installation already,
-just as one normally has a working C installation in place.
-The story of how to bring up a new Go installation from source
-is described <a href="/s/go15bootstrap">separately</a>.
+We also considered writing <code>gc</code>, the original Go compiler, in Go itself but
+elected not to do so because of the difficulties of bootstrapping and
+especially of open source distribution&mdash;you'd need a Go compiler to
+set up a Go environment. <code>Gccgo</code>, which came later, makes it possible to
+consider writing a compiler in Go.
+A plan to do that by machine translation of the existing compiler is under development.
+<a href="http://golang.org/s/go13compiler">A separate document</a>
+explains the reason for this approach.
 </p>

 <p>
-Go is a fine language in which to implement a Go compiler.
-Although <code>gc</code> does not use them (yet?), a native lexer and
-parser are available in the <a href="/pkg/go/"><code>go</code></a> package
-and there is also a <a href="/pkg/go/types">type checker</a>.
+That plan aside,
+Go is a
+fine language in which to implement a self-hosting compiler: a native lexer and
+parser are already available in the <a href="/pkg/go/"><code>go</code></a> package
+and a separate type checking
+<a href="http://godoc.org/golang.org/x/tools/go/types">package</a>
+has also been written.
 </p>

 <h3 id="How_is_the_run_time_support_implemented">
@@ -1783,11 +1625,15 @@ How is the run-time support implemented?</h3>

 <p>
 Again due to bootstrapping issues, the run-time code was originally written mostly in C (with a
-tiny bit of assembler) but it has since been translated to Go
-(except for some assembler bits).
+tiny bit of assembler) although much of it has been translated to Go since then
+and one day all of it might be (except for the assembler bits).
 <code>Gccgo</code>'s run-time support uses <code>glibc</code>.
-The <code>gccgo</code> compiler implements goroutines using
-a technique called segmented stacks,
+<code>Gc</code> uses a custom C library to keep the footprint under
+control; it is
+compiled with a version of the Plan 9 C compiler that supports
+resizable stacks for goroutines.
+The <code>gccgo</code> compiler implements these on Linux only,
+using a technique called segmented stacks,
 supported by recent modifications to the gold linker.
 </p>

@@ -1795,8 +1641,8 @@ supported by recent modifications to the gold linker.
 Why is my trivial program such a large binary?</h3>

 <p>
-The linker in the <code>gc</code> tool chain
-creates statically-linked binaries by default.  All Go binaries therefore include the Go
+The linkers in the gc tool chain (<code>5l</code>, <code>6l</code>, and <code>8l</code>)
+do static linking.  All Go binaries therefore include the Go
 run-time, along with the run-time type information necessary to support dynamic
 type checks, reflection, and even panic-time stack traces.
 </p>
@@ -1806,7 +1652,7 @@ A simple C "hello, world" program compiled and linked statically using gcc
 on Linux is around 750 kB,
 including an implementation of <code>printf</code>.
 An equivalent Go program using <code>fmt.Printf</code>
-is around 1.5 MB, but
+is around 1.9 MB, but
 that includes more powerful run-time support and type information.
 </p>

@@ -1883,16 +1729,15 @@ Why does Go perform badly on benchmark X?</h3>
 <p>
 One of Go's design goals is to approach the performance of C for comparable
 programs, yet on some benchmarks it does quite poorly, including several
-in <a href="https://go.googlesource.com/exp/+/master/shootout/">golang.org/x/exp/shootout</a>.
-The slowest depend on libraries for which versions of comparable performance
-are not available in Go.
-For instance, <a href="https://go.googlesource.com/exp/+/master/shootout/pidigits.go">pidigits.go</a>
+in <a href="/test/bench/shootout/">test/bench/shootout</a>. The slowest depend on libraries
+for which versions of comparable performance are not available in Go.
+For instance, <a href="/test/bench/shootout/pidigits.go">pidigits.go</a>
 depends on a multi-precision math package, and the C
 versions, unlike Go's, use <a href="http://gmplib.org/">GMP</a> (which is
 written in optimized assembler).
 Benchmarks that depend on regular expressions
-(<a href="https://go.googlesource.com/exp/+/master/shootout/regex-dna.go">regex-dna.go</a>,
-for instance) are essentially comparing Go's native <a href="/pkg/regexp">regexp package</a> to
+(<a href="/test/bench/shootout/regex-dna.go">regex-dna.go</a>, for instance) are
+essentially comparing Go's native <a href="/pkg/regexp">regexp package</a> to
 mature, highly optimized regular expression libraries like PCRE.
 </p>

@@ -1900,9 +1745,9 @@ mature, highly optimized regular expression libraries like PCRE.
 Benchmark games are won by extensive tuning and the Go versions of most
 of the benchmarks need attention.  If you measure comparable C
 and Go programs
-(<a href="https://go.googlesource.com/exp/+/master/shootout/reverse-complement.go">reverse-complement.go</a>
-is one example), you'll see the two languages are much closer in raw performance
-than this suite would indicate.
+(<a href="/test/bench/shootout/reverse-complement.go">reverse-complement.go</a> is one example), you'll see the two
+languages are much closer in raw performance than this suite would
+indicate.
 </p>

 <p>
@@ -2066,12 +1911,8 @@ simpler because they don't need to specify how memory is managed across them.
 </p>

 <p>
-The current implementation is a parallel mark-and-sweep collector.
-Recent improvements, documented in
-<a href="/s/go14gc">this design document</a>,
-have introduced bounded pause times and improved the
-parallelism.
-Future versions might attempt new approaches.
+The current implementation is a parallel mark-and-sweep
+collector but a future version might take a different approach.
 </p>

 <p>
--- a/doc/go_mem.html
+++ b/doc/go_mem.html
@@ -322,11 +322,11 @@ var limit = make(chan int, 3)

 func main() {
 	for _, w := range work {
-		go func(w func()) {
-			limit &lt;- 1
+		go func() {
+			limit <- 1
 			w()
-			&lt;-limit
-		}(w)
+			<-limit
+		}()
 	}
 	select{}
 }
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
--- a/doc/gopher/README
+++ b/doc/gopher/README
@@ -1,3 +1,3 @@
 The Go gopher was designed by Renee French. (http://reneefrench.blogspot.com/)
 The design is licensed under the Creative Commons 3.0 Attributions license.
-Read this article for more details: https://blog.golang.org/gopher
+Read this article for more details: http://blog.golang.org/gopher
--- a/doc/gopher/favicon.svg
+++ b/doc/gopher/favicon.svg
@@ -1,238 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="32"
-   height="32"
-   viewBox="0 0 32 32.000001"
-   id="svg4416"
-   version="1.1"
-   inkscape:version="0.91 r13725"
-   sodipodi:docname="favicon.svg"
-   inkscape:export-filename="../../favicon.png"
-   inkscape:export-xdpi="90"
-   inkscape:export-ydpi="90">
-  <defs
-     id="defs4418" />
-  <sodipodi:namedview
-     id="base"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageopacity="0.0"
-     inkscape:pageshadow="2"
-     inkscape:zoom="15.839192"
-     inkscape:cx="17.966652"
-     inkscape:cy="9.2991824"
-     inkscape:document-units="px"
-     inkscape:current-layer="layer1"
-     showgrid="true"
-     units="px"
-     inkscape:snap-bbox="true"
-     inkscape:snap-bbox-edge-midpoints="false"
-     inkscape:bbox-nodes="true"
-     showguides="false"
-     inkscape:window-width="1920"
-     inkscape:window-height="1018"
-     inkscape:window-x="1912"
-     inkscape:window-y="-8"
-     inkscape:window-maximized="1"
-     inkscape:object-nodes="true"
-     inkscape:snap-smooth-nodes="true"
-     inkscape:snap-global="false">
-    <inkscape:grid
-       type="xygrid"
-       id="grid5148" />
-  </sodipodi:namedview>
-  <metadata
-     id="metadata4421">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title />
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     inkscape:label="icon"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(0,-1020.3622)">
-    <ellipse
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#384e54;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="ellipse4216"
-       cx="-907.35657"
-       cy="479.90009"
-       rx="3.5793996"
-       ry="3.8207953"
-       transform="matrix(-0.49169095,-0.87076978,-0.87076978,0.49169095,0,0)"
-       inkscape:transform-center-x="0.67794294"
-       inkscape:transform-center-y="-2.3634048" />
-    <ellipse
-       inkscape:transform-center-y="-2.3633882"
-       inkscape:transform-center-x="-0.67793718"
-       transform="matrix(0.49169095,-0.87076978,0.87076978,0.49169095,0,0)"
-       ry="3.8207953"
-       rx="3.5793996"
-       cy="507.8461"
-       cx="-891.57654"
-       id="ellipse4463"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#384e54;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" />
-    <path
-       inkscape:connector-curvature="0"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#384e54;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       d="m 16.091693,1021.3642 c -1.105749,0.01 -2.210341,0.049 -3.31609,0.09 C 6.8422558,1021.6738 2,1026.3942 2,1032.3622 c 0,2.9786 0,13 0,20 l 28,0 c 0,-8 0,-16 0,-20 0,-5.9683 -4.667345,-10.4912 -10.59023,-10.908 -1.10575,-0.078 -2.212328,-0.099 -3.318077,-0.09 z"
-       id="path4465"
-       sodipodi:nodetypes="ccsccscc" />
-    <path
-       inkscape:transform-center-y="-1.3604657"
-       inkscape:transform-center-x="-0.98424303"
-       sodipodi:nodetypes="sssssss"
-       inkscape:connector-curvature="0"
-       id="path4469"
-       d="m 4.6078867,1025.0462 c 0.459564,0.2595 1.818262,1.2013 1.980983,1.648 0.183401,0.5035 0.159385,1.0657 -0.114614,1.551 -0.346627,0.6138 -1.005341,0.9487 -1.696421,0.9365 -0.339886,-0.01 -1.720283,-0.6372 -2.042561,-0.8192 -0.97754,-0.5519 -1.350795,-1.7418 -0.833686,-2.6576 0.517109,-0.9158 1.728749,-1.2107 2.706299,-0.6587 z"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#76e1fe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" />
-    <rect
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#000000;fill-opacity:0.32850246;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="rect4473"
-       width="3.0866659"
-       height="3.5313663"
-       x="14.406213"
-       y="1035.6842"
-       ry="0.62426329" />
-    <path
-       inkscape:connector-curvature="0"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#76e1fe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       d="m 16,1023.3622 c -9,0 -12,3.7153 -12,9 l 0,20 24,0 c -0.04889,-7.3562 0,-18 0,-20 0,-5.2848 -3,-9 -12,-9 z"
-       id="path4471"
-       sodipodi:nodetypes="zsccsz" />
-    <path
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#76e1fe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       d="m 27.074073,1025.0462 c -0.45957,0.2595 -1.818257,1.2013 -1.980979,1.648 -0.183401,0.5035 -0.159384,1.0657 0.114614,1.551 0.346627,0.6138 1.005335,0.9487 1.696415,0.9365 0.33988,-0.01 1.72029,-0.6372 2.04256,-0.8192 0.97754,-0.5519 1.35079,-1.7418 0.83369,-2.6576 -0.51711,-0.9158 -1.72876,-1.2107 -2.7063,-0.6587 z"
-       id="path4481"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="sssssss"
-       inkscape:transform-center-x="0.98424094"
-       inkscape:transform-center-y="-1.3604657" />
-    <circle
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="circle4477"
-       cx="21.175734"
-       cy="1030.3542"
-       r="4.6537542"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <circle
-       r="4.8316345"
-       cy="1030.3542"
-       cx="10.339486"
-       id="circle4483"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <rect
-       inkscape:export-ydpi="90"
-       inkscape:export-xdpi="90"
-       inkscape:export-filename=".\rect4485.png"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#000000;fill-opacity:0.32941176;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="rect4246"
-       width="3.6673687"
-       height="4.1063409"
-       x="14.115863"
-       y="1035.9174"
-       ry="0.72590536" />
-    <rect
-       ry="0.72590536"
-       y="1035.2253"
-       x="14.115863"
-       height="4.1063409"
-       width="3.6673687"
-       id="rect4485"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#fffcfb;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#000000;fill-opacity:0.32941176;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       d="m 19.999735,1036.5289 c 0,0.838 -0.871228,1.2682 -2.144766,1.1659 -0.02366,0 -0.04795,-0.6004 -0.254147,-0.5832 -0.503669,0.042 -1.095902,-0.02 -1.685964,-0.02 -0.612939,0 -1.206342,0.1826 -1.68549,0.017 -0.110233,-0.038 -0.178298,0.5838 -0.261532,0.5816 -1.243685,-0.033 -2.078803,-0.3383 -2.078803,-1.1618 0,-1.2118 1.815635,-2.1941 4.055351,-2.1941 2.239704,0 4.055351,0.9823 4.055351,2.1941 z"
-       id="path4487"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="sssssssss"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       sodipodi:nodetypes="sssssssss"
-       inkscape:connector-curvature="0"
-       id="path4489"
-       d="m 19.977414,1035.7004 c 0,0.5685 -0.433659,0.8554 -1.138091,1.0001 -0.291933,0.06 -0.630371,0.096 -1.003719,0.1166 -0.56405,0.032 -1.207782,0.031 -1.89122,0.031 -0.672834,0 -1.307182,0 -1.864904,-0.029 -0.306268,-0.017 -0.589429,-0.043 -0.843164,-0.084 -0.813833,-0.1318 -1.324962,-0.417 -1.324962,-1.0344 0,-1.1601 1.805642,-2.1006 4.03303,-2.1006 2.227377,0 4.03303,0.9405 4.03303,2.1006 z"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#c38c74;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <ellipse
-       cy="1033.8501"
-       cx="15.944382"
-       id="ellipse4491"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#23201f;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       rx="2.0801733"
-       ry="1.343747"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <circle
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#171311;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       id="circle4493"
-       cx="12.414201"
-       cy="1030.3542"
-       r="1.9630634"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <circle
-       r="1.9630634"
-       cy="1030.3542"
-       cx="23.110121"
-       id="circle4495"
-       style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#171311;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
-       inkscape:export-filename=".\rect4485.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       sodipodi:nodetypes="cc"
-       inkscape:connector-curvature="0"
-       id="path4497"
-       d="m 5.0055377,1027.2727 c -1.170435,-1.0835 -2.026973,-0.7721 -2.044172,-0.7463"
-       style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
-    <path
-       style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="m 4.3852457,1026.9152 c -1.158557,0.036 -1.346704,0.6303 -1.33881,0.6523"
-       id="path4499"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="cc" />
-    <path
-       style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
-       d="m 26.630533,1027.1724 c 1.17043,-1.0835 2.02697,-0.7721 2.04417,-0.7463"
-       id="path4501"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="cc" />
-    <path
-       sodipodi:nodetypes="cc"
-       inkscape:connector-curvature="0"
-       id="path4503"
-       d="m 27.321773,1026.673 c 1.15856,0.036 1.3467,0.6302 1.3388,0.6522"
-       style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
-  </g>
-</svg>
--- a/doc/help.html
+++ b/doc/help.html
@@ -1,71 +1,46 @@
 <!--{
-	"Title": "Help",
+	"Title": "Getting Help",
 	"Path": "/help/"
 }-->

-<div id="manual-nav"></div>
-
-<h2 id="help">Get help</h2>
-
 <img class="gopher" src="/doc/gopher/help.png"/>

-<h3 id="mailinglist"><a href="https://groups.google.com/group/golang-nuts">Go Nuts Mailing List</a></h3>
 <p>
-Get help from Go users, and share your work on the official mailing list.
+Need help with Go? Try these resources.
 </p>
+
+<div id="manual-nav"></div>
+
+<h3 id="faq"><a href="/doc/faq">Frequently Asked Questions (FAQ)</a></h3>
+<p>Answers to common questions about Go.</p>
+
+<h3 id="playground"><a href="/play">The Go Playground</a></h3>
+<p>A place to write, run, and share Go code.</p>
+
+<h3 id="wiki"><a href="/wiki">The Go Wiki</a></h3>
+<p>A wiki maintained by the Go community.</p>
+
+<h3 id="mailinglist"><a href="//groups.google.com/group/golang-nuts">Go Nuts Mailing List</a></h3>
 <p>
-Search the <a href="https://groups.google.com/group/golang-nuts">golang-nuts</a>
+Search the <a href="//groups.google.com/group/golang-nuts">golang-nuts</a>
 archives and consult the <a href="/doc/go_faq.html">FAQ</a> and
-<a href="//golang.org/wiki">wiki</a> before posting.
+<a href="//code.google.com/p/go-wiki/wiki">wiki</a> before posting.
 </p>

-<h3 id="forum"><a href="https://forum.golangbridge.org/">Go Forum</a></h3>
-<p>
-The <a href="https://forum.golangbridge.org/">Go Forum</a> is a discussion
-forum for Go programmers.
-</p>
-
-<h3 id="slack"><a href="https://blog.gopheracademy.com/gophers-slack-community/">Gopher Slack</a></h3>
-<p>Get live support from other users in the Go slack channel.</p>
-
 <h3 id="irc"><a href="irc:irc.freenode.net/go-nuts">Go IRC Channel</a></h3>
 <p>Get live support at <b>#go-nuts</b> on <b>irc.freenode.net</b>, the official
 Go IRC channel.</p>

-<h3 id="faq"><a href="/doc/faq">Frequently Asked Questions (FAQ)</a></h3>
-<p>Answers to common questions about Go.</p>
+<h3 id="pluscom"><a href="https://plus.google.com/communities/114112804251407510571">The Go+ community</a></h3>
+<p>The Google+ community for Go enthusiasts.</p>

-<h2 id="inform">Stay informed</h2>
+<h3 id="plus"><a href="https://plus.google.com/101406623878176903605/posts">The Go Programming Language at Google+</a></h3>
+<p>The Go project's Google+ page.</p>

-<h3 id="announce"><a href="https://groups.google.com/group/golang-announce">Go Announcements Mailing List</a></h3>
-<p>
-Subscribe to
-<a href="https://groups.google.com/group/golang-announce">golang-announce</a>
-for important announcements, such as the availability of new Go releases.
-</p>
-
-<h3 id="blog"><a href="//blog.golang.org">Go Blog</a></h3>
-<p>The Go project's official blog.</p>
-
-<h3 id="twitter"><a href="https://twitter.com/golang">@golang at Twitter</a></h3>
+<h3 id="twitter"><a href="//twitter.com/golang">@golang at Twitter</a></h3>
 <p>The Go project's official Twitter account.</p>
-
-<h3 id="pluscom"><a href="https://plus.google.com/communities/114112804251407510571">Go+ community</a></h3>
-<p>A Google+ community for Go enthusiasts.</p>
-
-<h3 id="reddit"><a href="https://reddit.com/r/golang">golang sub-Reddit</a></h3>
-<p>
-The <a href="https://reddit.com/r/golang">golang sub-Reddit</a> is a place
-for Go news and discussion.
-</p>
-
-<h3 id="gotime"><a href="https://changelog.com/gotime">Go Time Podcast</a></h3>
-<p>
-The <a href="https://changelog.com/gotime">Go Time podcast</a> is a panel of Go experts and special guests
-discussing the Go programming language, the community, and everything in between.
-</p>
-
-<h2 id="community">Community resources</h2>
+<p>Tweeting about your problem with the <code>#golang</code> hashtag usually
+generates some helpful responses.</p>

 <h3 id="go_user_groups"><a href="/wiki/GoUserGroups">Go User Groups</a></h3>
 <p>
@@ -73,15 +48,3 @@ Each month in places around the world, groups of Go programmers ("gophers")
 meet to talk about Go. Find a chapter near you.
 </p>

-<h3 id="playground"><a href="/play">Go Playground</a></h3>
-<p>A place to write, run, and share Go code.</p>
-
-<h3 id="wiki"><a href="/wiki">Go Wiki</a></h3>
-<p>A wiki maintained by the Go community.</p>
-
-<h3 id="conduct"><a href="/conduct">Code of Conduct</a></h3>
-<p>
-Guidelines for participating in Go community spaces
-and a reporting process for handling issues.
-</p>
-
--- a/doc/install-source.html
+++ b/doc/install-source.html
@@ -26,66 +26,38 @@ packages, though, read on.
 <p>
 There are two official Go compiler tool chains.
 This document focuses on the <code>gc</code> Go
-compiler and tools.
+compiler and tools (<code>6g</code>, <code>8g</code> etc.).
 For information on how to work on <code>gccgo</code>, a more traditional
 compiler using the GCC back end, see
 <a href="/doc/install/gccgo">Setting up and using gccgo</a>.
 </p>

 <p>
-The Go compilers support eight instruction sets.
+The Go compilers support three instruction sets.
 There are important differences in the quality of the compilers for the different
 architectures.
 </p>

 <dl>
 <dt>
-	<code>amd64</code> (also known as <code>x86-64</code>)
+	<code>amd64</code> (a.k.a. <code>x86-64</code>); <code>6g,6l,6c,6a</code>
 </dt>
 <dd>
-	A mature implementation.
+	A mature implementation. The compiler has an effective
+	optimizer (registerizer) and generates good code (although
+	<code>gccgo</code> can do noticeably better sometimes).
 </dd>
 <dt>
-	<code>386</code> (<code>x86</code> or <code>x86-32</code>)
+	<code>386</code> (a.k.a. <code>x86</code> or <code>x86-32</code>); <code>8g,8l,8c,8a</code>
 </dt>
 <dd>
 	Comparable to the <code>amd64</code> port.
 </dd>
 <dt>
-	<code>arm</code> (<code>ARM</code>)
+	<code>arm</code> (a.k.a. <code>ARM</code>); <code>5g,5l,5c,5a</code>
 </dt>
 <dd>
-	Supports Linux, FreeBSD, NetBSD, OpenBSD and Darwin binaries. Less widely used than the other ports.
-</dd>
-<dt>
-	<code>arm64</code> (<code>AArch64</code>)
-</dt>
-<dd>
-	Supports Linux and Darwin binaries. New in 1.5 and not as well exercised as other ports.
-</dd>
-<dt>
-	<code>ppc64, ppc64le</code> (64-bit PowerPC big- and little-endian)
-</dt>
-<dd>
-	Supports Linux binaries. New in 1.5 and not as well exercised as other ports.
-</dd>
-<dt>
-	<code>mips, mipsle</code> (32-bit MIPS big- and little-endian)
-</dt>
-<dd>
-	Supports Linux binaries. New in 1.8 and not as well exercised as other ports.
-</dd>
-<dt>
-	<code>mips64, mips64le</code> (64-bit MIPS big- and little-endian)
-</dt>
-<dd>
-	Supports Linux binaries. New in 1.6 and not as well exercised as other ports.
-</dd>
-<dt>
-	<code>s390x</code> (IBM System z)
-</dt>
-<dd>
-	Supports Linux binaries. New in 1.7 and not as well exercised as other ports.
+	Supports Linux, FreeBSD and NetBSD binaries. Less widely used than the other ports.
 </dd>
 </dl>

@@ -103,146 +75,68 @@ The full set of supported combinations is listed in the discussion of
 <a href="#environment">environment variables</a> below.
 </p>

-<p>
-See the main installation page for the <a href="/doc/install#requirements">overall system requirements</a>.
-The following additional constraints apply to systems that can be built only from source:
-</p>
-
-<ul>
-<li>For Linux on PowerPC 64-bit, the minimum supported kernel version is 2.6.37, meaning that
-Go does not support CentOS 6 on these systems.
-</li>
-</ul>
-
 </div>

-<h2 id="go14">Install Go compiler binaries</h2>
+<h2 id="ctools">Install C tools, if needed</h2>

 <p>
-The Go tool chain is written in Go. To build it, you need a Go compiler installed.
-The scripts that do the initial build of the tools look for an existing Go tool
-chain in <code>$GOROOT_BOOTSTRAP</code>.
-If unset, the default value of <code>GOROOT_BOOTSTRAP</code>
-is <code>$HOME/go1.4</code>.
+The Go tool chain is written in C. To build it, you need a C compiler installed. 
+Please refer to the <a href="//golang.org/wiki/InstallFromSource#Install_C_tools">InstallFromSource</a>
+page on the Go community Wiki for operating system specific instructions.
+</p>
+
+<h2 id="mercurial">Install Mercurial, if needed</h2>
+
+<p>
+To perform the next step you must have Mercurial installed. (Check that you
+have an <code>hg</code> command.)
 </p>

 <p>
-There are many options for the bootstrap tool chain.
-After obtaining one, set <code>GOROOT_BOOTSTRAP</code> to the
-directory containing the unpacked tree.
-For example, <code>$GOROOT_BOOTSTRAP/bin/go</code> should be
-the <code>go</code> command binary for the bootstrap tool chain.
-</p>
-
-<p>
-To use a binary release as a bootstrap tool chain, see
-<a href="/dl/">the downloads page</a> or use any other
-packaged Go distribution.
-</p>
-
-<p>
-To build a bootstrap tool chain from source, use
-either the git branch <code>release-branch.go1.4</code> or
-<a href="https://storage.googleapis.com/golang/go1.4-bootstrap-20170531.tar.gz">go1.4-bootstrap-20170531.tar.gz</a>,
-which contains the Go 1.4 source code plus accumulated fixes
-to keep the tools running on newer operating systems.
-(Go 1.4 was the last distribution in which the tool chain was written in C.)
-After unpacking the Go 1.4 source, <code>cd</code> to
-the <code>src</code> subdirectory and run <code>make.bash</code> (or,
-on Windows, <code>make.bat</code>).
-</p>
-
-<p>
-To cross-compile a bootstrap tool chain from source, which is
-necessary on systems Go 1.4 did not target (for
-example, <code>linux/ppc64le</code>), install Go on a different system
-and run <a href="/src/bootstrap.bash">bootstrap.bash</a>.
-</p>
-
-<p>
-When run as (for example)
-</p>
-
-<pre>
-$ GOOS=linux GOARCH=ppc64 ./bootstrap.bash
-</pre>
-
-<p>
-<code>bootstrap.bash</code> cross-compiles a toolchain for that <code>GOOS/GOARCH</code>
-combination, leaving the resulting tree in <code>../../go-${GOOS}-${GOARCH}-bootstrap</code>.
-That tree can be copied to a machine of the given target type
-and used as <code>GOROOT_BOOTSTRAP</code> to bootstrap a local build.
-</p>
-
-<p>
-To use gccgo as the bootstrap toolchain, you need to arrange
-for <code>$GOROOT_BOOTSTRAP/bin/go</code> to be the go tool that comes
-as part of gccgo 5. For example on Ubuntu Vivid:
-</p>
-
-<pre>
-$ sudo apt-get install gccgo-5
-$ sudo update-alternatives --set go /usr/bin/go-5
-$ GOROOT_BOOTSTRAP=/usr ./make.bash
-</pre>
-
-<h2 id="git">Install Git, if needed</h2>
-
-<p>
-To perform the next step you must have Git installed. (Check that you
-have a <code>git</code> command before proceeding.)
-</p>
-
-<p>
-If you do not have a working Git installation,
+If you do not have a working Mercurial installation,
 follow the instructions on the
-<a href="http://git-scm.com/downloads">Git downloads</a> page.
-</p>
-
-<h2 id="ccompiler">(Optional) Install a C compiler</h2>
-
-<p>
-To build a Go installation
-with <code><a href="/cmd/cgo">cgo</a></code> support, which permits Go
-programs to import C libraries, a C compiler such as <code>gcc</code>
-or <code>clang</code> must be installed first. Do this using whatever
-installation method is standard on the system.
+<a href="http://mercurial.selenic.com/downloads">Mercurial downloads</a> page.
 </p>

 <p>
-To build without <code>cgo</code>, set the environment variable
-<code>CGO_ENABLED=0</code> before running <code>all.bash</code> or
-<code>make.bash</code>.
+Mercurial versions 1.7.x and up require the configuration of
+<a href="http://mercurial.selenic.com/wiki/CACertificates">Certification Authorities</a>
+(CAs). Error messages of the form:
 </p>

+<pre>
+warning: code.google.com certificate with fingerprint b1:af: ... bc not verified (check hostfingerprints or web.cacerts config setting)
+</pre>
+
+<p>
+when using Mercurial indicate that the CAs are missing.
+Check your Mercurial version (<code>hg --version</code>) and
+<a href="http://mercurial.selenic.com/wiki/CACertificates#Configuration_of_HTTPS_certificate_authorities">configure the CAs</a>
+if necessary.
+</p>
+
+
 <h2 id="fetch">Fetch the repository</h2>

 <p>Go will install to a directory named <code>go</code>.
 Change to the directory that will be its parent
 and make sure the <code>go</code> directory does not exist.
-Then clone the repository and check out the latest release tag
-(<code class="versionTag">go1.8.1</code>, for example):</p>
+Then check out the repository:</p>

 <pre>
-$ git clone https://go.googlesource.com/go
-$ cd go
-$ git checkout <span class="versionTag"><i>&lt;tag&gt;</i></span>
+$ hg clone -u release https://code.google.com/p/go
 </pre>

-<p class="whereTag">
-Where <code>&lt;tag&gt;</code> is the version string of the release.
-</p>
-
-<h2 id="head">(Optional) Switch to the master branch</h2>
+<h2 id="head">(Optional) Switch to the default branch</h2>

 <p>If you intend to modify the go source code, and
 <a href="/doc/contribute.html">contribute your changes</a>
 to the project, then move your repository
-off the release branch, and onto the master (development) branch.
+off the release branch, and onto the default (development) branch.
 Otherwise, skip this step.</p>

 <pre>
-$ git checkout master
+$ hg update default
 </pre>

 <h2 id="install">Install Go</h2>
@@ -252,7 +146,7 @@ To build the Go distribution, run
 </p>

 <pre>
-$ cd src
+$ cd go/src
 $ ./all.bash
 </pre>

@@ -338,7 +232,7 @@ You just need to do a little more setup.
 </p>

 <p>
-The <a href="/doc/code.html">How to Write Go Code</a> document
+The <a href="/doc/code.html">How to Write Go Code</a> document 
 provides <b>essential setup instructions</b> for using the Go tools.
 </p>

@@ -364,8 +258,8 @@ $ go get golang.org/x/tools/cmd/godoc
 </pre>

 <p>
-To install these tools, the <code>go</code> <code>get</code> command requires
-that <a href="#git">Git</a> be installed locally.
+To install these tools, the <code>go</code> <code>get</code> command requires 
+that <a href="#mercurial">Mercurial</a> be installed locally.
 </p>

 <p>
@@ -398,18 +292,22 @@ that receives a message summarizing each checkin to the Go repository.
 </p>

 <p>
-Bugs can be reported using the <a href="//golang.org/issue/new">Go issue tracker</a>.
+Bugs can be reported using the <a href="//code.google.com/p/go/issues/list">Go issue tracker</a>.
 </p>


 <h2 id="releases">Keeping up with releases</h2>

 <p>
-New releases are announced on the
+The Go project maintains a stable tag in its Mercurial repository:
+<code>release</code>.
+</p>
+
+<p>
+The <code>release</code> tag refers to the current stable release of Go.
+Most Go users should use this version. New releases are announced on the
 <a href="//groups.google.com/group/golang-announce">golang-announce</a>
 mailing list.
-Each announcement mentions the latest release tag, for instance,
-<code class="versionTag">go1.8.1</code>.
 </p>

 <p>
@@ -418,15 +316,11 @@ To update an existing tree to the latest release, you can run:

 <pre>
 $ cd go/src
-$ git fetch
-$ git checkout <span class="versionTag"><i>&lt;tag&gt;</i></psan>
+$ hg pull
+$ hg update release
 $ ./all.bash
 </pre>

-<p class="whereTag">
-Where <code>&lt;tag&gt;</code> is the version string of the release.
-</p>
-

 <h2 id="environment">Optional environment variables</h2>

@@ -439,7 +333,7 @@ to override the defaults.
 <ul>
 <li><code>$GOROOT</code>
 <p>
-The root of the Go tree, often <code>$HOME/go1.X</code>.
+The root of the Go tree, often <code>$HOME/go</code>.
 Its value is built into the tree when it is compiled, and
 defaults to the parent of the directory where <code>all.bash</code> was run.
 There is no need to set this unless you want to switch between multiple
@@ -452,7 +346,7 @@ The value assumed by installed binaries and scripts when
 <code>$GOROOT</code> is not set explicitly.
 It defaults to the value of <code>$GOROOT</code>.
 If you want to build the Go tree in one location
-but move it elsewhere after the build, set
+but move it elsewhere after the build, set 
 <code>$GOROOT_FINAL</code> to the eventual location.
 </p>

@@ -464,34 +358,25 @@ These default to the values of <code>$GOHOSTOS</code> and

 <p>
 Choices for <code>$GOOS</code> are
-<code>darwin</code> (Mac OS X 10.8 and above and iOS), <code>dragonfly</code>, <code>freebsd</code>,
-<code>linux</code>, <code>netbsd</code>, <code>openbsd</code>,
+<code>darwin</code> (Mac OS X 10.6 and above), <code>dragonfly</code>, <code>freebsd</code>,
+<code>linux</code>, <code>netbsd</code>, <code>openbsd</code>, 
 <code>plan9</code>, <code>solaris</code> and <code>windows</code>.
 Choices for <code>$GOARCH</code> are
 <code>amd64</code> (64-bit x86, the most mature port),
-<code>386</code> (32-bit x86), <code>arm</code> (32-bit ARM), <code>arm64</code> (64-bit ARM),
-<code>ppc64le</code> (PowerPC 64-bit, little-endian), <code>ppc64</code> (PowerPC 64-bit, big-endian),
-<code>mips64le</code> (MIPS 64-bit, little-endian), and <code>mips64</code> (MIPS 64-bit, big-endian).
-<code>mipsle</code> (MIPS 32-bit, little-endian), and <code>mips</code> (MIPS 32-bit, big-endian).
+<code>386</code> (32-bit x86), and <code>arm</code> (32-bit ARM).
 The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <table cellpadding="0">
 <tr>
 <th width="50"></th><th align="left" width="100"><code>$GOOS</code></th> <th align="left" width="100"><code>$GOARCH</code></th>
 </tr>
 <tr>
-<td></td><td><code>android</code></td> <td><code>arm</code></td>
-</tr>
-<tr>
 <td></td><td><code>darwin</code></td> <td><code>386</code></td>
 </tr>
 <tr>
 <td></td><td><code>darwin</code></td> <td><code>amd64</code></td>
 </tr>
 <tr>
-<td></td><td><code>darwin</code></td> <td><code>arm</code></td>
-</tr>
-<tr>
-<td></td><td><code>darwin</code></td> <td><code>arm64</code></td>
+<td></td><td><code>dragonfly</code></td> <td><code>386</code></td>
 </tr>
 <tr>
 <td></td><td><code>dragonfly</code></td> <td><code>amd64</code></td>
@@ -515,27 +400,6 @@ The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <td></td><td><code>linux</code></td> <td><code>arm</code></td>
 </tr>
 <tr>
-<td></td><td><code>linux</code></td> <td><code>arm64</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>ppc64</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>ppc64le</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>mips</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>mipsle</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>mips64</code></td>
-</tr>
-<tr>
-<td></td><td><code>linux</code></td> <td><code>mips64le</code></td>
-</tr>
-<tr>
 <td></td><td><code>netbsd</code></td> <td><code>386</code></td>
 </tr>
 <tr>
@@ -551,9 +415,6 @@ The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <td></td><td><code>openbsd</code></td> <td><code>amd64</code></td>
 </tr>
 <tr>
-<td></td><td><code>openbsd</code></td> <td><code>arm</code></td>
-</tr>
-<tr>
 <td></td><td><code>plan9</code></td> <td><code>386</code></td>
 </tr>
 <tr>
@@ -569,7 +430,6 @@ The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <td></td><td><code>windows</code></td> <td><code>amd64</code></td>
 </tr>
 </table>
-<br>

 <li><code>$GOHOSTOS</code> and <code>$GOHOSTARCH</code>
 <p>
@@ -582,7 +442,7 @@ architecture.
 Valid choices are the same as for <code>$GOOS</code> and
 <code>$GOARCH</code>, listed above.
 The specified values must be compatible with the local system.
-For example, you should not set <code>$GOHOSTARCH</code> to
+For example, you should not set <code>$GOHOSTARCH</code> to 
 <code>arm</code> on an x86 system.
 </p>

@@ -599,7 +459,7 @@ installs all commands there.
 <li><code>$GO386</code> (for <code>386</code> only, default is auto-detected
 if built on either <code>386</code> or <code>amd64</code>, <code>387</code> otherwise)
 <p>
-This controls the code generated by gc to use either the 387 floating-point unit
+This controls the code generated by 8g to use either the 387 floating-point unit
 (set to <code>387</code>) or SSE2 instructions (set to <code>sse2</code>) for
 floating point computations.
 </p>
@@ -643,12 +503,12 @@ not <code>amd64</code>.
 <p>
 If you choose to override the defaults,
 set these variables in your shell profile (<code>$HOME/.bashrc</code>,
-<code>$HOME/.profile</code>, or equivalent). The settings might look
+<code>$HOME/.profile</code>, or equivalent). The settings might look 
 something like this:
 </p>

 <pre>
-export GOROOT=$HOME/go1.X
+export GOROOT=$HOME/go
 export GOARCH=amd64
 export GOOS=linux
 </pre>
--- a/doc/install.html
+++ b/doc/install.html
@@ -3,12 +3,10 @@
 	"Path":  "/doc/install"
 }-->

-<div class="hideFromDownload">
-
 <h2 id="download">Download the Go distribution</h2>

 <p>
-<a href="https://golang.org/dl/" id="start" class="download">
+<a href="https://golang.org/dl/" id="start" class="download" target="_blank">
 <span class="big">Download Go</span>
 <span class="desc">Click here to visit the downloads page</span>
 </a>
@@ -16,10 +14,9 @@

 <p>
 <a href="https://golang.org/dl/" target="_blank">Official binary
-distributions</a> are available for the FreeBSD (release 8-STABLE and above),
-Linux, Mac OS X (10.8 and above), and Windows operating systems and
-the 32-bit (<code>386</code>) and 64-bit (<code>amd64</code>) x86 processor
-architectures.
+distributions</a> are available for the FreeBSD (release 8 and above), Linux, Mac OS X (Snow Leopard
+and above), and Windows operating systems and the 32-bit (<code>386</code>) and
+64-bit (<code>amd64</code>) x86 processor architectures.
 </p>

 <p>
@@ -33,11 +30,11 @@ system and architecture, try
 <h2 id="requirements">System requirements</h2>

 <p>
-Go <a href="https://golang.org/dl/">binary distributions</a> are available for these supported operating systems and architectures.
-Please ensure your system meets these requirements before proceeding.
-If your OS or architecture is not on the list, you may be able to
-<a href="/doc/install/source">install from source</a> or
-<a href="/doc/install/gccgo">use gccgo instead</a>.
+The <code>gc</code> compiler supports the following operating systems and
+architectures. Please ensure your system meets these requirements before
+proceeding. If your OS or architecture is not on the list, it's possible that
+<code>gccgo</code> might support your setup; see
+<a href="/doc/install/gccgo">Setting up and using gccgo</a> for details.
 </p>

 <table class="codetable" frame="border" summary="requirements">
@@ -47,14 +44,14 @@ If your OS or architecture is not on the list, you may be able to
 <th align="center">Notes</th>
 </tr>
 <tr><td colspan="3"><hr></td></tr>
-<tr><td>FreeBSD 9.3 or later</td> <td>amd64, 386</td> <td>Debian GNU/kFreeBSD not supported</td></tr>
-<tr valign='top'><td>Linux 2.6.23 or later with glibc</td> <td>amd64, 386, arm, arm64,<br>s390x, ppc64le</td> <td>CentOS/RHEL 5.x not supported.<br>Install from source for other libc.</td></tr>
-<tr><td>macOS 10.8 or later</td> <td>amd64</td> <td>use the clang or gcc<sup>&#8224;</sup> that comes with Xcode<sup>&#8225;</sup> for <code>cgo</code> support</td></tr>
-<tr><td>Windows XP SP2 or later</td> <td>amd64, 386</td> <td>use MinGW gcc<sup>&#8224;</sup>. No need for cygwin or msys.</td></tr>
+<tr><td>FreeBSD 8 or later</td> <td>amd64, 386, arm</td> <td>Debian GNU/kFreeBSD not supported; FreeBSD/ARM needs FreeBSD 10 or later</td></tr>
+<tr><td>Linux 2.6.23 or later with glibc</td> <td>amd64, 386, arm</td> <td>CentOS/RHEL 5.x not supported; no binary distribution for ARM yet</td></tr>
+<tr><td>Mac OS X 10.6 or later</td> <td>amd64, 386</td> <td>use the gcc<sup>&#8224;</sup> that comes with Xcode<sup>&#8225;</sup></td></tr>
+<tr><td>Windows XP or later</td> <td>amd64, 386</td> <td>use MinGW gcc<sup>&#8224;</sup>. No need for cygwin or msys.</td></tr>
 </table>

 <p>
-<sup>&#8224;</sup>A C compiler is required only if you plan to use
+<sup>&#8224;</sup><code>gcc</code> is required only if you plan to use
 <a href="/cmd/cgo">cgo</a>.<br/>
 <sup>&#8225;</sup>You only need to install the command line tools for
 <a href="http://developer.apple.com/Xcode/">Xcode</a>. If you have already
@@ -62,8 +59,6 @@ installed Xcode 4.3+, you can install it from the Components tab of the
 Downloads preferences panel.
 </p>

-</div><!-- hideFromDownload -->
-

 <h2 id="install">Install the Go tools</h2>

@@ -72,8 +67,6 @@ If you are upgrading from an older version of Go you must
 first <a href="#uninstall">remove the existing version</a>.
 </p>

-<div id="tarballInstructions">
-
 <h3 id="tarball">Linux, Mac OS X, and FreeBSD tarballs</h3>

 <p>
@@ -83,10 +76,10 @@ and extract it into <code>/usr/local</code>, creating a Go tree in
 </p>

 <pre>
-tar -C /usr/local -xzf <span class="downloadFilename">go$VERSION.$OS-$ARCH.tar.gz</span>
+tar -C /usr/local -xzf go$VERSION.$OS-$ARCH.tar.gz
 </pre>

-<p class="hideFromDownload">
+<p>
 Choose the archive file appropriate for your installation.
 For instance, if you are installing Go version 1.2.1 for 64-bit x86 on Linux,
 the archive you want is called <code>go1.2.1.linux-amd64.tar.gz</code>.
@@ -117,12 +110,12 @@ to point to the directory in which it was installed.
 </p>

 <p>
-For example, if you installed Go to your home directory you should add
-commands like the following to <code>$HOME/.profile</code>:
+For example, if you installed Go to your home directory you should add the
+following commands to <code>$HOME/.profile</code>:
 </p>

 <pre>
-export GOROOT=$HOME/go1.X
+export GOROOT=$HOME/go
 export PATH=$PATH:$GOROOT/bin
 </pre>

@@ -131,10 +124,6 @@ export PATH=$PATH:$GOROOT/bin
 location.
 </p>

-</div><!-- tarballInstructions -->
-
-<div id="darwinPackageInstructions">
-
 <h3 id="osx">Mac OS X package installer</h3>

 <p>
@@ -149,21 +138,15 @@ The package should put the <code>/usr/local/go/bin</code> directory in your
 Terminal sessions for the change to take effect.
 </p>

-</div><!-- darwinPackageInstructions -->
-
-<div id="windowsInstructions">
-
 <h3 id="windows">Windows</h3>

-<p class="hideFromDownload">
+<p>
 The Go project provides two installation options for Windows users
 (besides <a href="/doc/install/source">installing from source</a>):
 a zip archive that requires you to set some environment variables and an
 MSI installer that configures your installation automatically.
 </p>

-<div id="windowsInstallerInstructions">
-
 <h4 id="windows_msi">MSI installer</h4>

 <p>
@@ -178,10 +161,6 @@ The installer should put the <code>c:\Go\bin</code> directory in your
 command prompts for the change to take effect.
 </p>

-</div><!-- windowsInstallerInstructions -->
-
-<div id="windowsZipInstructions">
-
 <h4 id="windows_zip">Zip archive</h4>

 <p>
@@ -197,8 +176,6 @@ you must set the <code>GOROOT</code> environment variable to your chosen path.
 Add the <code>bin</code> subdirectory of your Go root (for example, <code>c:\Go\bin</code>) to your <code>PATH</code> environment variable.
 </p>

-</div><!-- windowsZipInstructions -->
-
 <h4 id="windows_env">Setting environment variables under Windows</h4>

 <p>
@@ -208,26 +185,15 @@ versions of Windows provide this control panel through the "Advanced System
 Settings" option inside the "System" control panel.
 </p>

-</div><!-- windowsInstructions -->
-

 <h2 id="testing">Test your installation</h2>

 <p>
-Check that Go is installed correctly by setting up a workspace
-and building a simple program, as follows.
+Check that Go is installed correctly by building a simple program, as follows.
 </p>

 <p>
-Create your <a href="code.html#Workspaces">workspace</a> directory,
-<code class="testUnix">$HOME/go</code><code class="testWindows">%USERPROFILE%\go</code>.
-(If you'd like to use a different directory,
-you will need to <a href="https://golang.org/wiki/SettingGOPATH">set the <code>GOPATH</code> environment variable</a>.)
-</p>
-
-<p>
-Next, make the directory <code>src/hello</code> inside your workspace,
-and in that directory create a file named <code>hello.go</code> that looks like:
+Create a file named <code>hello.go</code> and put the following program in it:
 </p>

 <pre>
@@ -241,33 +207,11 @@ func main() {
 </pre>

 <p>
-Then build it with the <code>go</code> tool:
+Then run it with the <code>go</code> tool:
 </p>

-<pre class="testUnix">
-$ <b>cd $HOME/go/src/hello</b>
-$ <b>go build</b>
-</pre>
-
-<pre class="testWindows">
-C:\&gt; <b>cd %USERPROFILE%\go\src\hello</b>
-C:\Users\Gopher\go\src\hello&gt; <b>go build</b>
-</pre>
-
-<p>
-The command above will build an executable named
-<code class="testUnix">hello</code><code class="testWindows">hello.exe</code>
-in the directory alongside your source code.
-Execute it to see the greeting:
-</p>
-
-<pre class="testUnix">
-$ <b>./hello</b>
-hello, world
-</pre>
-
-<pre class="testWindows">
-C:\Users\Gopher\go\src\hello&gt; <b>hello</b>
+<pre>
+$ go run hello.go
 hello, world
 </pre>

@@ -275,16 +219,17 @@ hello, world
 If you see the "hello, world" message then your Go installation is working.
 </p>

+
+<h2 id="gopath">Set up your work environment</h2>
+
 <p>
-You can run <code>go</code> <code>install</code> to install the binary into
-your workspace's <code>bin</code> directory
-or <code>go</code> <code>clean</code> to remove it.
+You're almost done.
+You just need to set up your environment.
 </p>

 <p>
-Before rushing off to write Go code please read the
-<a href="/doc/code.html">How to Write Go Code</a> document,
-which describes some essential concepts about using the Go tools.
+Read the <a href="/doc/code.html">How to Write Go Code</a> document,
+which provides <b>essential setup instructions</b> for using the Go tools.
 </p>


@@ -312,10 +257,16 @@ environment variables under Windows</a>.
 <h2 id="help">Getting help</h2>

 <p>
-  For help, see the <a href="/help/">list of Go mailing lists, forums, and places to chat</a>.
+For real-time help, ask the helpful gophers in <code>#go-nuts</code> on the
+<a href="http://freenode.net/">Freenode</a> IRC server.
 </p>

 <p>
-  Report bugs either by running “<b><code>go</code> <code>bug</code></b>”, or
-  manually at the <a href="https://golang.org/issue">Go issue tracker</a>.
+The official mailing list for discussion of the Go language is
+<a href="//groups.google.com/group/golang-nuts">Go Nuts</a>.
+</p>
+
+<p>
+Report bugs using the
+<a href="//golang.org/issue">Go issue tracker</a>.
 </p>
--- a/doc/logo-153x55.png
+++ b/doc/logo-153x55.png
--- a/doc/play/peano.go
+++ b/doc/play/peano.go
@@ -3,9 +3,9 @@
 // (the nodes are the data).
 // http://en.wikipedia.org/wiki/Peano_axioms

-// This program demonstrates that Go's automatic
-// stack management can handle heavily recursive
-// computations.
+// This program demonstrates the power of Go's
+// segmented stacks when doing massively
+// recursive computations.

 package main

--- a/doc/play/pi.go
+++ b/doc/play/pi.go
@@ -1,5 +1,5 @@
 // Concurrent computation of pi.
-// See https://goo.gl/la6Kli.
+// See http://goo.gl/ZuTZM.
 //
 // This demonstrates Go's ability to handle
 // large numbers of concurrent processes.
--- a/doc/progs/cgo1.go
+++ b/doc/progs/cgo1.go
@@ -1,7 +1,8 @@
+// skip
+
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
-
 package rand

 /*
--- a/doc/progs/cgo2.go
+++ b/doc/progs/cgo2.go
@@ -1,7 +1,8 @@
+// skip
+
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
-
 package rand2

 /*
--- a/doc/progs/cgo3.go
+++ b/doc/progs/cgo3.go
@@ -1,7 +1,8 @@
+// skip
+
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
-
 package print

 // #include <stdio.h>
--- a/doc/progs/cgo4.go
+++ b/doc/progs/cgo4.go
@@ -1,7 +1,8 @@
+// skip
+
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
-
 package print

 // #include <stdio.h>
--- a/doc/progs/defer.go
+++ b/doc/progs/defer.go
@@ -1,3 +1,5 @@
+// cmpout
+
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
--- a/doc/progs/defer.out
+++ b/doc/progs/defer.out
@@ -0,0 +1,3 @@
+0
+3210
+2
--- a/doc/progs/defer2.go
+++ b/doc/progs/defer2.go
@@ -1,3 +1,5 @@
+// cmpout
+
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
--- a/doc/progs/defer2.out
+++ b/doc/progs/defer2.out
@@ -0,0 +1,12 @@
+Calling g.
+Printing in g 0
+Printing in g 1
+Printing in g 2
+Printing in g 3
+Panicking!
+Defer in g 3
+Defer in g 2
+Defer in g 1
+Defer in g 0
+Recovered in f 4
+Returned normally from f.
--- a/doc/progs/eff_bytesize.go
+++ b/doc/progs/eff_bytesize.go
@@ -1,3 +1,5 @@
+// cmpout
+
 // 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.
--- a/doc/progs/eff_bytesize.out
+++ b/doc/progs/eff_bytesize.out
@@ -0,0 +1 @@
+1.00YB 9.09TB
--- a/doc/progs/eff_qr.go
+++ b/doc/progs/eff_qr.go
@@ -1,3 +1,5 @@
+// compile
+
 // 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.
--- a/doc/progs/eff_sequence.go
+++ b/doc/progs/eff_sequence.go
@@ -1,3 +1,5 @@
+// cmpout
+
 // 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.
--- a/doc/progs/eff_sequence.out
+++ b/doc/progs/eff_sequence.out
@@ -0,0 +1 @@
+[-1 2 6 16 44]
--- a/doc/progs/eff_unused1.go
+++ b/doc/progs/eff_unused1.go
@@ -1,3 +1,5 @@
+// skip
+
 package main

 import (
--- a/doc/progs/eff_unused2.go
+++ b/doc/progs/eff_unused2.go
@@ -1,3 +1,5 @@
+// compile
+
 package main

 import (
--- a/doc/progs/error.go
+++ b/doc/progs/error.go
@@ -1,3 +1,5 @@
+// compile
+
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
--- a/doc/progs/error2.go
+++ b/doc/progs/error2.go
@@ -1,3 +1,5 @@
+// compile
+
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
--- a/doc/progs/error3.go
+++ b/doc/progs/error3.go
@@ -1,3 +1,5 @@
+// compile
+
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
--- a/doc/progs/error4.go
+++ b/doc/progs/error4.go
@@ -1,3 +1,5 @@
+// compile
+
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
--- a/doc/progs/go1.go
+++ b/doc/progs/go1.go
@@ -1,3 +1,6 @@
+// compile
+// this file will output a list of filenames in cwd, not suitable for cmpout
+
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
--- a/doc/progs/gobs1.go
+++ b/doc/progs/gobs1.go
@@ -1,3 +1,5 @@
+// compile
+
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
--- a/doc/progs/gobs2.go
+++ b/doc/progs/gobs2.go
@@ -1,3 +1,5 @@
+// compile
+
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
--- a/doc/progs/image_draw.go
+++ b/doc/progs/image_draw.go
@@ -1,3 +1,5 @@
+// compile
+
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
--- a/doc/progs/image_package1.go
+++ b/doc/progs/image_package1.go
@@ -1,3 +1,5 @@
+// cmpout
+
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
--- a/doc/progs/image_package1.out
+++ b/doc/progs/image_package1.out
@@ -0,0 +1 @@
+X is 2 Y is 1
--- a/doc/progs/image_package2.go
+++ b/doc/progs/image_package2.go
@@ -1,3 +1,5 @@
+// cmpout
+
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
--- a/doc/progs/image_package2.out
+++ b/doc/progs/image_package2.out
@@ -0,0 +1 @@
+3 4 false
--- a/doc/progs/image_package3.go
+++ b/doc/progs/image_package3.go
@@ -1,3 +1,5 @@
+// cmpout
+
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
--- a/doc/progs/image_package3.out
+++ b/doc/progs/image_package3.out
@@ -0,0 +1 @@
+3 4 true
--- a/doc/progs/image_package4.go
+++ b/doc/progs/image_package4.go
@@ -1,3 +1,5 @@
+// cmpout
+
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Andrew Gerrand	3d34461177	go1.4rc2 LGTM=rsc R=rsc CC=golang-codereviews https://golang.org/cl/179700043	2014-12-02 13:43:43 +11:00
Russ Cox	28208eb8e3	[release-branch.go1.4] runtime: fix hang in GC due to shrinkstack vs netpoll race ««« CL 179680043 / 752cd9199639 runtime: fix hang in GC due to shrinkstack vs netpoll race During garbage collection, after scanning a stack, we think about shrinking it to reclaim some memory. The shrinking code (called while the world is stopped) checked that the status was Gwaiting or Grunnable and then changed the state to Gcopystack, to essentially lock the stack so that no other GC thread is scanning it. The same locking happens for stack growth (and is more necessary there). oldstatus = runtime·readgstatus(gp); oldstatus &= ~Gscan; if(oldstatus == Gwaiting \|\| oldstatus == Grunnable) runtime·casgstatus(gp, oldstatus, Gcopystack); // oldstatus is Gwaiting or Grunnable else runtime·throw("copystack: bad status, not Gwaiting or Grunnable"); Unfortunately, "stop the world" doesn't stop everything. It stops all normal goroutine execution, but the network polling thread is still blocked in epoll and may wake up. If it does, and it chooses a goroutine to mark runnable, and that goroutine is the one whose stack is shrinking, then it can happen that between readgstatus and casgstatus, the status changes from Gwaiting to Grunnable. casgstatus assumes that if the status is not what is expected, it is a transient change (like from Gwaiting to Gscanwaiting and back, or like from Gwaiting to Gcopystack and back), and it loops until the status has been restored to the expected value. In this case, the status has changed semi-permanently from Gwaiting to Grunnable - it won't change again until the GC is done and the world can continue, but the GC is waiting for the status to change back. This wedges the program. To fix, call a special variant of casgstatus that accepts either Gwaiting or Grunnable as valid statuses. Without the fix bug with the extra check+throw in casgstatus, the program below dies in a few seconds (2-10) with GOMAXPROCS=8 on a 2012 Retina MacBook Pro. With the fix, it runs for minutes and minutes. package main import ( "io" "log" "net" "runtime" ) func main() { const N = 100 for i := 0; i < N; i++ { l, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { log.Fatal(err) } ch := make(chan net.Conn, 1) go func() { var err error c1, err := net.Dial("tcp", l.Addr().String()) if err != nil { log.Fatal(err) } ch <- c1 }() c2, err := l.Accept() if err != nil { log.Fatal(err) } c1 := <-ch l.Close() go netguy(c1, c2) go netguy(c2, c1) c1.Write(make([]byte, 100)) } for { runtime.GC() } } func netguy(r, w net.Conn) { buf := make([]byte, 100) for { bigstack(1000) _, err := io.ReadFull(r, buf) if err != nil { log.Fatal(err) } w.Write(buf) } } var g int func bigstack(n int) { var buf [100]byte if n > 0 { bigstack(n - 1) } g = int(buf[0]) + int(buf[99]) } Fixes #9186. LGTM=rlh R=austin, rlh CC=dvyukov, golang-codereviews, iant, khr, r https://golang.org/cl/179680043 »»» TBR=rlh CC=golang-codereviews https://golang.org/cl/184030043	2014-12-01 16:42:41 -05:00
Russ Cox	95e92ac420	[release-branch.go1.4] reflect: Fix reflect.funcLayout. The GC bitmap has two bits per ««« CL 182160043 / 321d04dea9d6 reflect: Fix reflect.funcLayout. The GC bitmap has two bits per pointer, not one. Fixes #9179 LGTM=iant, rsc R=golang-codereviews, iant, rsc CC=golang-codereviews https://golang.org/cl/182160043 »»» TBR=khr CC=golang-codereviews https://golang.org/cl/180440044	2014-12-01 11:18:47 -05:00
Andrew Gerrand	783ad67982	[release-branch.go1.4] doc: tidy up "Projects" page; add Go 1.4 ««« CL 182750043 / ffe33f1f1f17 doc: tidy up "Projects" page; add Go 1.4 LGTM=r R=r CC=golang-codereviews https://golang.org/cl/182750043 »»» TBR=r CC=golang-codereviews https://golang.org/cl/176350043	2014-11-26 07:57:03 +11:00
Russ Cox	d3ae115c41	[release-branch.go1.4] go/build: build $GOOS_test.go always ««« CL 176290043 / 8025b7d1e6c9 go/build: build $GOOS_test.go always We decided to build $GOOS.go always but forgot to test $GOOS_test.go. Fixes #9159. LGTM=r R=r CC=golang-codereviews https://golang.org/cl/176290043 »»» LGTM=r R=r CC=golang-codereviews https://golang.org/cl/182740043	2014-11-24 22:00:01 -05:00
Russ Cox	738ccf32d9	[release-branch.go1.4] image/jpeg: handle Read returning n > 0, err != nil in d.fill ««« CL 178120043 / 95f5614b4648 image/jpeg: handle Read returning n > 0, err != nil in d.fill Fixes #9127. LGTM=r R=bradfitz, r CC=golang-codereviews, nigeltao https://golang.org/cl/178120043 »»» TBR=r CC=golang-codereviews https://golang.org/cl/181870043	2014-11-23 11:15:26 -05:00
Russ Cox	f6818121ed	[release-branch.go1.4] cmd/go: fix running pprof on windows. ««« CL 176170043 / 61bbf19823d5 cmd/go: fix running pprof on windows. Fixes #9149. LGTM=alex.brainman, rsc R=rsc, dave, alex.brainman CC=golang-codereviews https://golang.org/cl/176170043 »»» TBR=minux CC=golang-codereviews https://golang.org/cl/175550043	2014-11-22 13:38:29 -05:00
Russ Cox	791fec05e4	[release-branch.go1.4] runtime: fix atomic operations on non-heap addresses ««« CL 179030043 / e4ab8f908aac runtime: fix atomic operations on non-heap addresses Race detector runtime does not tolerate operations on addresses that was not previously declared with __tsan_map_shadow (namely, data, bss and heap). The corresponding address checks for atomic operations were removed in https://golang.org/cl/111310044 Restore these checks. It's tricker than just not calling into race runtime, because it is the race runtime that makes the atomic operations themselves (if we do not call into race runtime we skip the atomic operation itself as well). So instead we call __tsan_go_ignore_sync_start/end around the atomic operation. This forces race runtime to skip all other processing except than doing the atomic operation itself. Fixes #9136. LGTM=rsc R=rsc CC=golang-codereviews https://golang.org/cl/179030043 »»» TBR=dvyukov CC=golang-codereviews https://golang.org/cl/180030043	2014-11-20 10:14:49 -05:00
Russ Cox	a791780bfd	[release-branch.go1.4] build: disable race external linking test on OS X 10.6 and earlier ««« CL 176070043 / 500cb52e08e6 build: disable race external linking test on OS X 10.6 and earlier External linking doesn't work there at all. LGTM=bradfitz R=adg, bradfitz CC=golang-codereviews https://golang.org/cl/176070043 »»» LGTM=bradfitz, adg R=adg, bradfitz CC=golang-codereviews https://golang.org/cl/175400043	2014-11-19 21:25:07 -05:00
Russ Cox	427ee80413	[release-branch.go1.4] runtime: remove assumption that noptrdata data bss noptrbss are ordered and contiguous ««« CL 179980043 / d71cc7e8a0e0 runtime: remove assumption that noptrdata data bss noptrbss are ordered and contiguous The assumption can be violated by external linkers reordering them or inserting non-Go sections in between them. I looked briefly at trying to write out the _go_.o in external linking mode in a way that forced the ordering, but no matter what there's no way to force Go's data and Go's bss to be next to each other. If there is any data or bss from non-Go objects, it's very likely to get stuck in between them. Instead, rewrite the two places we know about that make the assumption. I grepped for noptrdata to look for more and didn't find any. The added race test (os/exec in external linking mode) fails without the changes in the runtime. It crashes with an invalid pointer dereference. Fixes #9133. LGTM=dneil R=dneil CC=dvyukov, golang-codereviews, iant https://golang.org/cl/179980043 »»» LGTM=dneil R=dneil CC=golang-codereviews https://golang.org/cl/173510043	2014-11-19 15:31:31 -05:00
Russ Cox	b4df0154c2	[release-branch.go1.4] undo CL 131750044 / 2d6d44ceb80e ««« CL 174450043 / 699cc091a16d undo CL 131750044 / 2d6d44ceb80e Breaks reading from stdin in parent after exec with SysProcAttr{Setpgid: true}. package main import ( "fmt" "os" "os/exec" "syscall" ) func main() { cmd := exec.Command("true") cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} cmd.Run() fmt.Printf("Hit enter:") os.Stdin.Read(make([]byte, 100)) fmt.Printf("Bye\n") } In go1.3, I type enter at the prompt and the program exits. With the CL being rolled back, the program wedges at the prompt. ««« original CL description syscall: SysProcAttr job control changes Making the child's process group the foreground process group and placing the child in a specific process group involves co-ordination between the parent and child that must be done post-fork but pre-exec. LGTM=iant R=golang-codereviews, gobot, iant, mikioh.mikioh CC=golang-codereviews https://golang.org/cl/131750044 »»» LGTM=minux, dneil R=dneil, minux CC=golang-codereviews, iant, michael.p.macinnis https://golang.org/cl/174450043 »»» LGTM=minux R=dneil, minux CC=golang-codereviews https://golang.org/cl/179970043	2014-11-19 14:38:22 -05:00
Andrew Gerrand	c9e183e781	[release-branch.go1.4] doc/go1.4.html: rewrite first sentence to make it clearer ««« CL 178910043 / 3916b070c5f3 doc/go1.4.html: rewrite first sentence to make it clearer The grammar was atrocious, probably the victim of an editing error. LGTM=bradfitz R=bradfitz CC=golang-codereviews https://golang.org/cl/178910043 »»» LGTM=r R=r CC=golang-codereviews https://golang.org/cl/175310043	2014-11-19 09:47:56 +11:00
Andrew Gerrand	30ef146819	[release-branch.go1.4] remove cmd/link from nacl test zip LGTM=dsymonds R=rsc, dsymonds CC=golang-codereviews https://golang.org/cl/179830043	2014-11-17 13:55:59 +11:00
Andrew Gerrand	daf5d41471	[release-branch.go1.4] remove cmd/link LGTM=dsymonds, minux R=rsc, dsymonds, minux CC=golang-codereviews https://golang.org/cl/176910043	2014-11-17 13:46:45 +11:00
Andrew Gerrand	c1fc059b08	[release-branch.go1.4] debug/goobj: move to cmd/internal/goobj ««« CL 174250043 / c16349455e05 debug/goobj: move to cmd/internal/goobj debug/goobj is not ready to be published but it is needed for the various binary-reading commands. Move to cmd/internal/goobj. (The Go 1.3 release branch deleted it, but that's not an option anymore due to the command dependencies. The API is still not vetted nor terribly well designed.) LGTM=adg, dsymonds R=adg, dsymonds CC=golang-codereviews https://golang.org/cl/174250043 »»» LGTM=rsc R=rsc CC=golang-codereviews https://golang.org/cl/177890043	2014-11-17 12:56:35 +11:00
Andrew Gerrand	335ad3db99	go1.4rc1	2014-11-17 09:37:04 +11:00