[release-branch.go1.5] cmd/newlink: remove from release branch

Change-Id: Iad86bde6f2e0482745a4000ec4e192ade352983b Reviewed-on: https://go-review.googlesource.com/13292 Reviewed-by: Russ Cox <rsc@golang.org> Run-TryBot: Andrew Gerrand <adg@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
[release-branch.go1.5] go1.5rc1
2026-02-02 17:05:05 +03:00 · 2015-08-06 04:06:12 +00:00 · 2015-08-06 03:32:40 +00:00
4685 changed files with 160177 additions and 627090 deletions
--- a/.github/ISSUE_TEMPLATE
+++ b/.github/ISSUE_TEMPLATE
@@ -1,20 +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/.gitignore
+++ b/.gitignore
@@ -18,28 +18,27 @@ _cgo_*
 _obj
 _test
 _testmain.go
+build.out
+test.out
+doc/articles/wiki/*.bin
+misc/cgo/life/run.out
+misc/cgo/stdio/run.out
+misc/cgo/testso/main
+src/cmd/**/y.output
+src/cmd/cgo/zdefaultcc.go
+src/cmd/go/zdefaultcc.go
+src/cmd/internal/obj/zbootstrap.go
+src/go/doc/headscan
+src/runtime/zversion.go
+src/unicode/maketables
+src/*.*/
+test/pass.out
+test/run.out
+test/times.out
+test/garbage/*.out
+goinstall.log
+last-change
+VERSION.cache

-/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/zdefaultcc.go
-/src/cmd/go/zosarch.go
-/src/cmd/internal/obj/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
+bin/
+pkg/
--- a/345
+++ b/345
@@ -2,86 +2,55 @@
 # This file is distinct from the CONTRIBUTORS files.
 # See the latter for an explanation.

-# Names should be added to this file as one of
-#     Organization's name
-#     Individual's name <submission email address>
-#     Individual's name <submission email address> <email2> <emailN>
-# See CONTRIBUTORS for the meaning of multiple email addresses.
+# Names should be added to this file as
+#	Name or Organization <email address>
+# The email address is not required for organizations.

 # Please keep the list sorted.

 A Medium Corporation
 Aamir Khan <syst3m.w0rm@gmail.com>
 Aaron France <aaron.l.france@gmail.com>
-Aaron Torres <tcboox@gmail.com>
-Abe Haskins <abeisgreat@abeisgreat.com>
 Abhinav Gupta <abhinav.g90@gmail.com>
 Adrian Nos <nos.adrian@gmail.com>
 Adrian O'Grady <elpollouk@gmail.com>
 Adrien Bustany <adrien-xx-google@bustany.org>
-Aécio Júnior <aeciodantasjunior@gmail.com>
 Ahmed Waheed Moanes <oneofone@gmail.com>
-Ahmy Yulrizka <yulrizka@gmail.com>
-Aiden Scandella <ai@uber.com>
 Ainar Garipov <gugl.zadolbal@gmail.com>
-Akihiro Suda <suda.kyoto@gmail.com>
 Akshat Kumar <seed@mail.nanosouffle.net>
 Alan Shreve <alan@inconshreveable.com>
-Albert Nigmatzianov <albertnigma@gmail.com>
 Albert Strasheim <fullung@gmail.com>
-Albert Yu <yukinying@gmail.com>
-Alberto Bertogli <albertito@blitiri.com.ar>
 Alberto Donizetti <alb.donizetti@gmail.com>
 Alberto García Hierro <alberto@garciahierro.com> <alberto.garcia.hierro@gmail.com>
 Aleksandar Dezelin <dezelin@gmail.com>
-Alessandro Arzilli <alessandro.arzilli@gmail.com>
-Alessandro Baffa <alessandro.baffa@gmail.com>
 Alex A Skinner <alex@lx.lc>
 Alex Brainman <alex.brainman@gmail.com>
-Alex Browne <stephenalexbrowne@gmail.com>
-Alex Carol <alex.carol.c@gmail.com>
 Alex Jin <toalexjin@gmail.com>
 Alex Plugaru <alex@plugaru.org> <alexandru.plugaru@gmail.com>
 Alex Schroeder <alex@gnu.org>
 Alex Sergeyev <abc@alexsergeyev.com>
-Alexander Demakin <alexander.demakin@gmail.com>
-Alexander Döring <email@alexd.ch>
 Alexander Larsson <alexander.larsson@gmail.com>
-Alexander Menzhinsky <amenzhinsky@gmail.com>
 Alexander Morozov <lk4d4math@gmail.com>
-Alexander Neumann <alexander@bumpern.de>
 Alexander Orlov <alexander.orlov@loxal.net>
 Alexander Reece <awreece@gmail.com>
 Alexander Surma <surma@surmair.de>
 Alexander Zhavnerchik <alex.vizor@gmail.com>
 Alexander Zolotov <goldifit@gmail.com>
 Alexandre Cesaro <alexandre.cesaro@gmail.com>
-Alexandre Fiori <fiorix@gmail.com>
 Alexandre Normand <alexandre.normand@gmail.com>
 Alexei Sholik <alcosholik@gmail.com>
 Alexey Borzenkov <snaury@gmail.com>
 Alexey Palazhchenko <alexey.palazhchenko@gmail.com>
-Aliaksandr Valialkin <valyala@gmail.com>
-Alif Rachmawadi <subosito@gmail.com>
-Allan Simon <allan.simon@supinfo.com>
-Alok Menghrajani <alok.menghrajani@gmail.com>
-Amazon.com, Inc
 Amir Mohammad Saied <amir@gluegadget.com>
 Amrut Joshi <amrut.joshi@gmail.com>
-Andre Nathan <andrenth@gmail.com>
-Andreas Auernhammer <aead@mail.de>
-Andreas Litt <andreas.litt@gmail.com>
 Andrei Korzhevskii <a.korzhevskiy@gmail.com>
 Andrei Vieru <euvieru@gmail.com>
-Andrew Austin <andrewaclt@gmail.com>
 Andrew Balholm <andybalholm@gmail.com>
 Andrew Bonventre <andybons@chromium.org>
 Andrew Bursavich <abursavich@gmail.com>
 Andrew Ekstedt <andrew.ekstedt@gmail.com>
-Andrew Etter <andrew.etter@gmail.com>
 Andrew Harding <andrew@spacemonkey.com>
 Andrew Lutomirski <andy@luto.us>
-Andrew Pogrebnoy <absourd.noise@gmail.com>
 Andrew Pritchard <awpritchard@gmail.com>
 Andrew Radev <andrey.radev@gmail.com>
 Andrew Skiba <skibaa@gmail.com>
@@ -91,43 +60,26 @@ Andrew Williams <williams.andrew@gmail.com>
 Andrey Mirtchovski <mirtchovski@gmail.com>
 Andrey Petrov <andrey.petrov@shazow.net>
 Andriy Lytvynov <lytvynov.a.v@gmail.com>
-Andy Balholm <andy@balholm.com>
 Andy Davis <andy@bigandian.com>
-Andy Finkenstadt <afinkenstadt@zynga.com>
 Andy Maloney <asmaloney@gmail.com>
 Anfernee Yongkun Gui <anfernee.gui@gmail.com>
-Angelo Bulfone <mbulfone@gmail.com>
 Anh Hai Trinh <anh.hai.trinh@gmail.com>
-Anmol Sethi <anmol@aubble.com>
 Anschel Schaffer-Cohen <anschelsc@gmail.com>
-Anthony Canino <anthony.canino1@gmail.com>
 Anthony Eufemio <anthony.eufemio@gmail.com>
 Anthony Martin <ality@pbrane.org>
 Anthony Starks <ajstarks@gmail.com>
-Anthony Woods <awoods@raintank.io>
-Antonio Bibiano <antbbn@gmail.com>
 Apisak Darakananda <pongad@gmail.com>
 Aram Hăvărneanu <aram@mgk.ro>
 Areski Belaid <areski@gmail.com>
-Arlo Breault <arlolra@gmail.com>
-ARM Ltd.
 Arnaud Ysmal <arnaud.ysmal@gmail.com>
 Arne Hormann <arnehormann@gmail.com>
-Arnout Engelen <arnout@bzzt.net>
 Aron Nopanen <aron.nopanen@gmail.com>
-Artyom Pervukhin <artyom.pervukhin@gmail.com>
 Arvindh Rajesh Tamilmani <art@a-30.net>
-Atin Malaviya <amalaviy@akamai.com>
 Ato Araki <ato.araki@gmail.com>
-Audrey Lim <audreylh@gmail.com>
-Augusto Roman <aroman@gmail.com>
 Aulus Egnatius Varialus <varialus@gmail.com>
 awaw fumin <awawfumin@gmail.com>
-Ayanamist Yang <ayanamist@gmail.com>
 Aymerick Jéhanne <aymerick@jehanne.org>
-Baiju Muthukadan <baiju.m.mail@gmail.com>
 Ben Burkert <ben@benburkert.com>
-Ben Lubar <ben.lubar@gmail.com>
 Ben Olive <sionide21@gmail.com>
 Benjamin Black <b@b3k.us>
 Benny Siegert <bsiegert@gmail.com>
@@ -138,25 +90,18 @@ Bjorn Tillenius <bjorn@tillenius.me>
 Bjorn Tipling <bjorn.tipling@gmail.com>
 Blake Gentry <blakesgentry@gmail.com>
 Blake Mizerany <blake.mizerany@gmail.com>
-Blixt <me@blixt.nyc>
 Bobby Powers <bobbypowers@gmail.com>
-Bolt
-Brady Catherman <brady@gmail.com>
-Brady Sullivan <brady@bsull.com>
 Brendan Daniel Tracey <tracey.brendan@gmail.com>
 Brett Cannon <bcannon@gmail.com>
 Brian Dellisanti <briandellisanti@gmail.com>
 Brian G. Merrell <bgmerrell@gmail.com>
 Brian Gitonga Marete <marete@toshnix.com> <bgmarete@gmail.com>
-Brian Kennedy <btkennedy@gmail.com>
 Brian Ketelsen <bketelsen@gmail.com>
 Brian Smith <ohohvi@gmail.com>
-Bryan Alexander <Kozical@msn.com>
 Bryan Ford <brynosaurus@gmail.com>
 Caine Tighe <arctanofyourface@gmail.com>
 Caleb Spare <cespare@gmail.com>
 Carl Chatfield <carlchatfield@gmail.com>
-Carl Johnson <me@carlmjohnson.net>
 Carlos Castillo <cookieo9@gmail.com>
 Carlos Cirello <uldericofilho@gmail.com>
 Case Nelson <case.nelson@gmail.com>
@@ -167,164 +112,107 @@ Charles L. Dorian <cldorian@gmail.com>
 Charles Lee <zombie.fml@gmail.com>
 Chris Dollin <ehog.hedge@gmail.com>
 Chris Farmiloe <chrisfarms@gmail.com>
-Chris Hines <chris.cs.guy@gmail.com>
 Chris Howey <howeyc@gmail.com>
 Chris Jones <chris@cjones.org>
 Chris Kastorff <encryptio@gmail.com>
 Chris Lennert <calennert@gmail.com>
 Chris McGee <sirnewton_01@yahoo.ca> <newton688@gmail.com>
-Chris Stockton <chrisstocktonaz@gmail.com>
-Christian Couder <chriscool@tuxfamily.org>
 Christian Himpel <chressie@googlemail.com>
 Christine Hansmann <chhansmann@gmail.com>
 Christoffer Buchholz <christoffer.buchholz@gmail.com>
 Christoph Hack <christoph@tux21b.org>
 Christopher Cahoon <chris.cahoon@gmail.com>
 Christopher Guiney <chris@guiney.net>
-Christopher Nelson <nadiasvertex@gmail.com>
 Christopher Nielsen <m4dh4tt3r@gmail.com>
 Christopher Redden <christopher.redden@gmail.com>
 Christopher Wedgwood <cw@f00f.org>
-CL Sung <clsung@gmail.com> <cl_sung@htc.com>
 Clement Skau <clementskau@gmail.com>
 CloudFlare Inc.
-Colin Edwards <colin@recursivepenguin.com>
 Colin Kennedy <moshen.colin@gmail.com>
-Conrad Irwin <conrad.irwin@gmail.com>
 Conrad Meyer <cemeyer@cs.washington.edu>
-CoreOS, Inc.
 Corey Thomasson <cthom.lists@gmail.com>
 Cristian Staretu <unclejacksons@gmail.com>
-Currant
-Cyrill Schumacher <cyrill@schumacher.fm>
 Damian Gryski <dgryski@gmail.com>
-Dan Caddigan <goldcaddy77@gmail.com>
 Dan Callahan <dan.callahan@gmail.com>
 Dan Peterson <dpiddy@gmail.com>
 Dan Sinclair <dan.sinclair@gmail.com>
 Daniel Fleischman <danielfleischman@gmail.com>
-Daniel Johansson <dajo2002@gmail.com>
-Daniel Kerwin <d.kerwin@gini.net>
 Daniel Krech <eikeon@eikeon.com>
 Daniel Lidén <daniel.liden.87@gmail.com>
-Daniel Martí <mvdan@mvdan.cc>
 Daniel Morsing <daniel.morsing@gmail.com>
-Daniel Ortiz Pereira da Silva <daniel.particular@gmail.com>
-Daniel Skinner <daniel@dasa.cc>
-Daniel Speichert <daniel@speichert.pl>
 Daniel Theophanes <kardianos@gmail.com>
 Darren Elwood <darren@textnode.com>
-Datong Sun <dndx@idndx.com>
 Dave Cheney <dave@cheney.net>
-David Brophy <dave@brophy.uk>
 David Bürgin <676c7473@gmail.com>
 David Calavera <david.calavera@gmail.com>
 David du Colombier <0intro@gmail.com>
 David Forsythe <dforsythe@gmail.com>
 David G. Andersen <dave.andersen@gmail.com>
-David Howden <dhowden@gmail.com>
 David Jakob Fritz <david.jakob.fritz@gmail.com>
 David Leon Gil <coruus@gmail.com>
-David R. Jenni <david.r.jenni@gmail.com>
-David Sansome <me@davidsansome.com>
-David Stainton <dstainton415@gmail.com>
 David Thomas <davidthomas426@gmail.com>
 David Titarenco <david.titarenco@gmail.com>
 Davies Liu <davies.liu@gmail.com>
 Dean Prichard <dean.prichard@gmail.com>
-Deepak Jois <deepak.jois@gmail.com>
-Denis Bernard <db047h@gmail.com>
 Denis Brandolini <denis.brandolini@gmail.com>
-Denys Honsiorovskyi <honsiorovskyi@gmail.com>
 Derek Buitenhuis <derek.buitenhuis@gmail.com>
 Derek Parker <parkerderek86@gmail.com>
-Derek Shockey <derek.shockey@gmail.com>
-Develer SRL
 Devon H. O'Dell <devon.odell@gmail.com>
-Dhaivat Pandit <dhaivatpandit@gmail.com>
 Dhiru Kholia <dhiru.kholia@gmail.com>
 Didier Spezia <didier.06@gmail.com>
 Dimitri Tcaciuc <dtcaciuc@gmail.com>
-Dirk Gadsden <dirk@esherido.com>
-Diwaker Gupta <diwakergupta@gmail.com>
-Dmitri Popov <operator@cv.dp-net.com>
 Dmitri Shuralyov <shurcooL@gmail.com>
-Dmitriy Dudkin <dudkin.dmitriy@gmail.com>
 Dmitriy Shelenin <deemok@googlemail.com> <deemok@gmail.com>
 Dmitry Chestnykh <dchest@gmail.com>
 Dmitry Savintsev <dsavints@gmail.com>
-Dmitry Yakunin <nonamezeil@gmail.com>
 Dominik Honnef <dominik.honnef@gmail.com>
-Donald Huang <don.hcd@gmail.com>
 Donovan Hide <donovanhide@gmail.com>
 Dropbox, Inc.
 Duncan Holm <mail@frou.org>
-Dustin Herbison <djherbis@gmail.com>
 Dustin Sallings <dsallings@gmail.com>
 Dustin Shields-Cloues <dcloues@gmail.com>
 Dvir Volk <dvir@everything.me> <dvirsky@gmail.com>
 Eden Li <eden.li@gmail.com>
-Edward Muller <edwardam@interlix.com>
 Egon Elbre <egonelbre@gmail.com>
 Ehren Kret <ehren.kret@gmail.com>
 Eivind Uggedal <eivind@uggedal.com>
 Elias Naur <elias.naur@gmail.com>
-Elliot Morrison-Reed <elliotmr@gmail.com>
 Emil Hessman <c.emil.hessman@gmail.com> <emil@hessman.se>
-Emmanuel Odeke <emm.odeke@gmail.com> <odeke@ualberta.ca>
-Empirical Interfaces Inc.
 Eoghan Sherry <ejsherry@gmail.com>
 Eric Clark <zerohp@gmail.com>
-Eric Engestrom <eric@engestrom.ch>
-Eric Lagergren <ericscottlagergren@gmail.com>
 Eric Milliken <emilliken@gmail.com>
 Eric Roshan-Eisner <eric.d.eisner@gmail.com>
 Erik Aigner <aigner.erik@gmail.com>
-Erik Dubbelboer <erik@dubbelboer.com>
 Erik St. Martin <alakriti@gmail.com>
 Erik Westrup <erik.westrup@gmail.com>
-Ernest Chiang <ernest_chiang@htc.com>
 Esko Luontola <esko.luontola@gmail.com>
-Euan Kemp <euank@euank.com>
 Evan Phoenix <evan@phx.io>
 Evan Shaw <chickencha@gmail.com>
 Ewan Chou <coocood@gmail.com>
-Fabian Wickborn <fabian@wickborn.net>
 Fabrizio Milo <mistobaan@gmail.com>
-Faiyaz Ahmed <ahmedf@vmware.com>
 Fan Hongjian <fan.howard@gmail.com>
 Fastly, Inc.
 Fatih Arslan <fatih@arslan.io>
 Fazlul Shahriar <fshahriar@gmail.com>
-Fedor Indutny <fedor@indutny.com>
 Felix Geisendörfer <haimuiba@gmail.com>
-Filippo Valsorda <hi@filippo.io>
 Firmansyah Adiputra <frm.adiputra@gmail.com>
 Florian Uekermann <florian@uekermann-online.de>
 Florian Weimer <fw@deneb.enyo.de>
 Florin Patan <florinpatan@gmail.com>
-Ford Hurley <ford.hurley@gmail.com>
-Francisco Claude <fclaude@recoded.cl>
 Francisco Souza <franciscossouza@gmail.com>
 Frederick Kelly Mayle III <frederickmayle@gmail.com>
 Fredrik Enestad <fredrik.enestad@soundtrackyourbrand.com>
 Frithjof Schulze <schulze@math.uni-hannover.de> <sfrithjof@gmail.com>
-Frits van Bommel <fvbommel@gmail.com>
 Gabriel Aszalos <gabriel.aszalos@gmail.com>
-Gabriel Russell <gabriel.russell@gmail.com>
-Gareth Paul Jones <gpj@foursquare.com>
 Gary Burd <gary@beagledreams.com>
-Gaurish Sharma <contact@gaurishsharma.com>
 Gautham Thambidorai <gautham.dorai@gmail.com>
 Geert-Johan Riemer <gjr19912@gmail.com>
-Geoffroy Lorieux <lorieux.g@gmail.com>
 Georg Reinke <guelfey@gmail.com>
 George Shammas <george@shamm.as> <georgyo@gmail.com>
 Gerasimos Dimitriadis <gedimitr@gmail.com>
 Gideon Jan-Wessel Redelinghuys <gjredelinghuys@gmail.com>
 Giles Lean <giles.lean@pobox.com>
 Giulio Iotti <dullgiulio@gmail.com>
-Gleb Stepanov <glebstepanov1992@gmail.com>
 Google Inc.
 Gordon Klaus <gordon.klaus@gmail.com>
 Graham King <graham4king@gmail.com>
@@ -335,59 +223,36 @@ Guobiao Mei <meiguobiao@gmail.com>
 Gustav Paul <gustav.paul@gmail.com>
 Gustavo Niemeyer <gustavo@niemeyer.net>
 Gwenael Treguier <gwenn.kahz@gmail.com>
-Gyu-Ho Lee <gyuhox@gmail.com>
-H. İbrahim Güngör <igungor@gmail.com>
 Hajime Hoshi <hajimehoshi@gmail.com>
 Hari haran <hariharan.uno@gmail.com>
 Hariharan Srinath <srinathh@gmail.com>
 Harley Laue <losinggeneration@gmail.com>
-Harry Moreno <morenoh149@gmail.com>
-Harshavardhana <hrshvardhana@gmail.com>
 Håvard Haugen <havard.haugen@gmail.com>
 Hector Chu <hectorchu@gmail.com>
 Hector Martin Cantero <hector@marcansoft.com>
 Henning Schmiedehausen <henning@schmiedehausen.org>
 Henrik Edwards <henrik.edwards@gmail.com>
-Henrik Hodne <henrik@hodne.io>
 Herbert Georg Fischer <herbert.fischer@gmail.com>
-Hironao OTSUBO <motemen@gmail.com>
-Hiroshi Ioka <hirochachacha@gmail.com>
-Hitoshi Mitake <mitake.hitoshi@gmail.com>
-Holden Huang <ttyh061@gmail.com>
 Hong Ruiqi <hongruiqi@gmail.com>
-Hsin-Ho Yeh <yhh92u@gmail.com>
-Hu Keping <hukeping@huawei.com>
-Ian Gudger <ian@loosescre.ws>
 IBM
 Icarus Sparry <golang@icarus.freeuk.com>
-Idora Shinatose <idora.shinatose@gmail.com>
 Igneous Systems, Inc.
 Igor Dolzhikov <bluesriverz@gmail.com>
 INADA Naoki <songofacandy@gmail.com>
 Ingo Krabbe <ikrabbe.ask@gmail.com>
 Ingo Oeser <nightlyone@googlemail.com>
-Intel Corporation
-Irieda Noboru <irieda@gmail.com>
 Isaac Wagner <ibw@isaacwagner.me>
-Ivan Babrou <ivan@cloudflare.com>
 Ivan Ukhov <ivan.ukhov@gmail.com>
-Jacob Hoffman-Andrews <github@hoffman-andrews.com>
 Jae Kwon <jae@tendermint.com>
 Jakob Borg <jakob@nym.se>
 Jakub Ryszard Czarnowicz <j.czarnowicz@gmail.com>
-James Bardin <j.bardin@gmail.com>
-James Clarke <jrtc27@jrtc27.com>
 James David Chalfant <james.chalfant@gmail.com>
 James Fysh <james.fysh@gmail.com>
 James Gray <james@james4k.com>
 James Meneghello <rawrz0r@gmail.com>
 James P. Cooper <jamespcooper@gmail.com>
-James Schofield <james@shoeboxapp.com>
-James Sweet <james.sweet88@googlemail.com>
 James Toy <nil@opensesame.st>
 James Whitehead <jnwhiteh@gmail.com>
-Jamie Beverly <jamie.r.beverly@gmail.com>
-Jamil Djadala <djadala@gmail.com>
 Jan H. Hosang <jan.hosang@gmail.com>
 Jan Mercl <0xjnml@gmail.com>
 Jan Mercl <befelemepeseveze@gmail.com>
@@ -395,133 +260,80 @@ Jan Newmarch <jan.newmarch@gmail.com>
 Jan Ziak <0xe2.0x9a.0x9b@gmail.com>
 Jani Monoses <jani.monoses@ubuntu.com>
 Jaroslavas Počepko <jp@webmaster.ms>
-Jason Barnett <jason.w.barnett@gmail.com>
 Jason Del Ponte <delpontej@gmail.com>
-Jason Smale <jsmale@zendesk.com>
 Jason Travis <infomaniac7@gmail.com>
 Jay Weisskopf <jay@jayschwa.net>
-Jean-Nicolas Moal <jn.moal@gmail.com>
 Jeff Hodges <jeff@somethingsimilar.com>
 Jeff R. Allen <jra@nella.org>
 Jeff Sickel <jas@corpus-callosum.com>
 Jeff Wendling <jeff@spacemonkey.com>
 Jens Frederich <jfrederich@gmail.com>
 Jeremy Jackins <jeremyjackins@gmail.com>
-Jeroen Bobbeldijk <jerbob92@gmail.com>
-Jess Frazelle <me@jessfraz.com>
-Jesse Szwedko <jesse.szwedko@gmail.com>
-Jihyun Yu <yjh0502@gmail.com>
 Jim McGrath <jimmc2@gmail.com>
 Jimmy Zelinskie <jimmyzelinskie@gmail.com>
 Jingcheng Zhang <diogin@gmail.com>
-Jingguo Yao <yaojingguo@gmail.com>
 Jiong Du <londevil@gmail.com>
-Jirka Daněk <dnk@mail.muni.cz>
 Joakim Sernbrant <serbaut@gmail.com>
-Joe Farrell <joe2farrell@gmail.com>
 Joe Harrison <joehazzers@gmail.com>
-Joe Henke <joed.henke@gmail.com>
 Joe Poirier <jdpoirier@gmail.com>
 Joe Shaw <joe@joeshaw.org>
-Joe Sylve <joe.sylve@gmail.com>
 Joe Tsai <joetsai@digital-static.net>
 Joel Stemmer <stemmertech@gmail.com>
-Johan Sageryd <j@1616.se>
 John Asmuth <jasmuth@gmail.com>
 John C Barstow <jbowtie@amathaine.com>
 John Graham-Cumming <jgc@jgc.org> <jgrahamc@gmail.com>
 John Howard Palevich <jack.palevich@gmail.com>
-John Jeffery <jjeffery@sp.com.au>
-John Jenkins <twodopeshaggy@gmail.com>
 John Potocny <johnp@vividcortex.com>
-John Schnake <schnake.john@gmail.com>
 John Shahid <jvshahid@gmail.com>
 John Tuley <john@tuley.org>
-Jonathan Boulle <jonathanboulle@gmail.com>
 Jonathan Gold <jgold.bg@gmail.com>
 Jonathan Mark <jhmark@xenops.com>
 Jonathan Rudenberg <jonathan@titanous.com>
 Jonathan Wills <runningwild@gmail.com>
 Jongmin Kim <atomaths@gmail.com>
-Joonas Kuorilehto <joneskoo@derbian.fi>
-Joop Kiefte <ikojba@gmail.com> <joop@kiefte.net>
-Jordan Lewis <jordanthelewis@gmail.com>
 Jose Luis Vázquez González <josvazg@gmail.com>
 Joseph Holsten <joseph@josephholsten.com>
 Josh Bleecher Snyder <josharian@gmail.com>
-Josh Chorlton <jchorlton@gmail.com>
 Josh Goebel <dreamer3@gmail.com>
 Josh Holland <jrh@joshh.co.uk>
 Joshua Chase <jcjoshuachase@gmail.com>
-Jostein Stuhaug <js@solidsystem.no>
 JT Olds <jtolds@xnet5.com>
 Jukka-Pekka Kekkonen <karatepekka@gmail.com>
-Julian Kornberger <jk+github@digineo.de>
 Julian Phillips <julian@quantumfyre.co.uk>
 Julien Schmidt <google@julienschmidt.com>
 Justin Nuß <nuss.justin@gmail.com>
-Justyn Temme <justyntemme@gmail.com>
 Kai Backman <kaib@golang.org>
-Kale Blankenship <kale@lemnisys.com>
 Kamil Kisiel <kamil@kamilkisiel.net> <kamil.kisiel@gmail.com>
 Kang Hu <hukangustc@gmail.com>
 Kato Kazuyoshi <kato.kazuyoshi@gmail.com>
 Katrina Owen <katrina.owen@gmail.com>
-Kaviraj Kanagaraj <kavirajkanagaraj@gmail.com>
-Keegan Carruthers-Smith <keegan.csmith@gmail.com>
 Kei Son <hey.calmdown@gmail.com>
-Keith Ball <inflatablewoman@gmail.com>
 Keith Rarick <kr@xph.us>
 Kelsey Hightower <kelsey.hightower@gmail.com>
 Kelvin Foo Chuan Lyi <vmirage@gmail.com>
 Ken Friedenbach <kenliz@cruzio.com>
 Ken Rockot <ken@oz.gs>
-Ken Sedgwick <ken@bonsai.com>
-Kenji Kaneda <kenji.kaneda@gmail.com>
-Kenneth Shaw <kenshaw@gmail.com>
-Kenny Grant <kennygrant@gmail.com>
 Kevin Ballard <kevin@sb.org>
-Kevin Burke <kev@inburke.com>
-Kevin Kirsche <kev.kirsche@gmail.com>
-Kevin Vu <kevin.m.vu@gmail.com>
-Klaus Post <klauspost@gmail.com>
 Konstantin Shaposhnikov <k.shaposhnikov@gmail.com>
-KPCompass, Inc.
-Kristopher Watts <traetox@gmail.com>
-Kun Li <likunarmstrong@gmail.com>
 Kyle Consalus <consalus@gmail.com>
 Kyle Isom <kyle@gokyle.net>
 Kyle Lemons <kyle@kylelemons.net>
 L Campbell <unpantsu@gmail.com>
 Lai Jiangshan <eag0628@gmail.com>
 Larz Conwell <larzconwell@gmail.com>
-LE Manh Cuong <cuong.manhle.vn@gmail.com>
-Lee Hinman <hinman@gmail.com>
 Lee Packham <lpackham@gmail.com>
-Lewin Bormann <lewin.bormann@gmail.com>
-Liberty Fund Inc
 Linaro Limited
 Lloyd Dewolf <foolswisdom@gmail.com>
 Lorenzo Stoakes <lstoakes@gmail.com>
-Luan Santos <cfcluan@gmail.com>
 Luca Greco <luca.greco@alcacoop.it>
-Lucien Stuker <lucien.stuker@gmail.com>
 Lucio De Re <lucio.dere@gmail.com>
-Luigi Riefolo <luigi.riefolo@gmail.com>
 Luit van Drongelen <luitvd@gmail.com>
 Luka Zakrajšek <tr00.g33k@gmail.com>
 Luke Curley <qpingu@gmail.com>
-Maksym Trykur <maksym.trykur@gmail.com>
-Mal Curtis <mal@mal.co.nz>
-Manfred Touron <m@42.am>
-Manu S Ajith <neo@codingarena.in>
 Manuel Mendez <mmendez534@gmail.com>
 Marc Weistroff <marc@weistroff.net>
-Marcel Edmund Franke <marcel.edmund.franke@gmail.com>
 Marco Hennings <marco.hennings@freiheit.com>
-Marin Bašić <marin.basic02@gmail.com>
 Mark Bucciarelli <mkbucc@gmail.com>
-Mark Severson <miquella@gmail.com>
 Mark Theunissen <mark.theunissen@gmail.com>
 Marko Juhani Silokunnas <marko.silokunnas@gmail.com>
 Marko Tiikkaja <marko@joh.to>
@@ -529,43 +341,27 @@ Markover Inc. DBA Poptip
 Markus Duft <markus.duft@salomon.at>
 Markus Sonderegger <marraison@gmail.com>
 Markus Zimmermann <zimmski@gmail.com>
-Martin Bertschler <mbertschler@gmail.com>
-Martin Garton <garton@gmail.com>
-Martin Hamrle <martin.hamrle@gmail.com>
 Martin Möhrmann <martisch@uos.de>
 Martin Neubauer <m.ne@gmx.net>
 Martin Olsson <martin@minimum.se>
-Marvin Stenger <marvin.stenger94@gmail.com>
 Mateusz Czapliński <czapkofan@gmail.com>
 Mathias Beke <git@denbeke.be>
-Mathias Leppich <mleppich@muhqu.de>
 Mathieu Lonjaret <mathieu.lonjaret@gmail.com>
 Mats Lidell <mats.lidell@cag.se>
 Matt Aimonetti <mattaimonetti@gmail.com>
 Matt Bostock <matt@mattbostock.com>
-Matt Drollette <matt@drollette.com>
 Matt Jibson <matt.jibson@gmail.com>
 Matt Joiner <anacrolix@gmail.com>
 Matt Layher <mdlayher@gmail.com>
 Matt Reiferson <mreiferson@gmail.com>
-Matt Robenolt <matt@ydekproductions.com>
 Matt T. Proud <matt.proud@gmail.com>
 Matt Williams <gh@mattyw.net>
 Matthew Brennan <matty.brennan@gmail.com>
 Matthew Cottingham <mattcottingham@gmail.com>
-Matthew Denton <mdenton@skyportsystems.com>
 Matthew Holt <Matthew.Holt+git@gmail.com>
 Matthew Horsnell <matthew.horsnell@gmail.com>
-Matthieu Hauglustaine <matt.hauglustaine@gmail.com>
-Matthieu Olivier <olivier.matthieu@gmail.com>
-Max Riveiro <kavu13@gmail.com>
 Maxim Khitrov <max@mxcrypt.com>
-Maxwell Krohn <themax@gmail.com>
-MediaMath, Inc
 Meir Fischer <meirfischer@gmail.com>
-Meng Zhuo <mengzhuo1203@gmail.com>
-Meteor Development Group
-Mhd Sulhan <m.shulhan@gmail.com>
 Micah Stetson <micah.stetson@gmail.com>
 Michael Chaten <mchaten@gmail.com>
 Michael Elkins <michael.elkins@gmail.com>
@@ -575,106 +371,65 @@ Michael Hoisie <hoisie@gmail.com>
 Michael Käufl <golang@c.michael-kaeufl.de>
 Michael Lewis <mikelikespie@gmail.com>
 Michael MacInnis <Michael.P.MacInnis@gmail.com>
-Michael McConville <momcconville@gmail.com>
 Michael Pearson <mipearson@gmail.com>
 Michael Schaller <michael@5challer.de>
 Michael Stapelberg <michael@stapelberg.de>
 Michael Teichgräber <mteichgraeber@gmx.de>
 Michael Vetter <g.bluehut@gmail.com>
-Michal Bohuslávek <mbohuslavek@gmail.com>
 Michał Derkacz <ziutek@lnet.pl>
 Miek Gieben <miek@miek.nl>
-Miguel Mendez <stxmendez@gmail.com>
 Mihai Borobocea <MihaiBorobocea@gmail.com>
 Mikael Tillenius <mikti42@gmail.com>
 Mike Andrews <mra@xoba.com>
-Mike Appleby <mike@app.leby.org>
-Mike Houston <mike@kothar.net>
 Mike Rosset <mike.rosset@gmail.com>
-Mikhail Gusarov <dottedmag@dottedmag.net>
 Mikhail Panchenko <m@mihasya.com>
 Miki Tebeka <miki.tebeka@gmail.com>
 Mikio Hara <mikioh.mikioh@gmail.com>
 Mikkel Krautz <mikkel@krautz.dk>
 Miquel Sabaté Solà <mikisabate@gmail.com>
-Miroslav Genov <mgenov@gmail.com>
-Mohit Agarwal <mohit@sdf.org>
-Momchil Velikov <momchil.velikov@gmail.com>
-Monty Taylor <mordred@inaugust.com>
 Moov Corporation
 Moriyoshi Koizumi <mozo@mozo.jp>
-Morten Siebuhr <sbhr@sbhr.dk>
 Môshe van der Sterre <moshevds@gmail.com>
-Muhammed Uluyol <uluyol0@gmail.com>
 Nan Deng <monnand@gmail.com>
 Nathan John Youngman <nj@nathany.com>
-Nathan Otterness <otternes@cs.unc.edu>
 Nathan P Finch <nate.finch@gmail.com>
-Nathan VanBenschoten <nvanbenschoten@gmail.com>
 Nathan Youngman <git@nathany.com>
-Neelesh Chandola <neelesh.c98@gmail.com>
-Netflix, Inc.
 Nevins Bartolomeo <nevins.bartolomeo@gmail.com>
 ngmoco, LLC
-Niall Sheridan <nsheridan@gmail.com>
-Nic Day <nic.day@me.com>
 Nicholas Katsaros <nick@nickkatsaros.com>
 Nicholas Presta <nick@nickpresta.ca> <nick1presta@gmail.com>
 Nicholas Sullivan <nicholas.sullivan@gmail.com>
 Nicholas Waples <nwaples@gmail.com>
 Nick Craig-Wood <nick@craig-wood.com> <nickcw@gmail.com>
-Nick Leli <nicholasleli@gmail.com>
-Nick Patavalis <nick.patavalis@gmail.com>
-Nick Petroni <npetroni@cs.umd.edu>
 Nicolas Kaiser <nikai@nikai.net>
 Nicolas Owens <mischief@offblast.org>
 Nicolas S. Dade <nic.dade@gmail.com>
-Niels Widger <niels.widger@gmail.com>
 Nigel Kerr <nigel.kerr@gmail.com>
-Nik Nyby <nnyby@columbia.edu>
-Niko Dziemba <niko@dziemba.com>
-Nikolay Turpitko <nikolay@turpitko.com>
 Noah Campbell <noahcampbell@gmail.com>
-Norberto Lopes <nlopes.ml@gmail.com>
-Odin Ugedal <odin@ugedal.com>
-Oleg Vakheta <helginet@gmail.com>
-Oleku Konko <oleku.konko@gmail.com>
 Oling Cat <olingcat@gmail.com>
 Oliver Hookins <ohookins@gmail.com>
 Olivier Antoine <olivier.antoine@gmail.com>
 Olivier Duperray <duperray.olivier@gmail.com>
-Olivier Poitrey <rs@dailymotion.com>
 Olivier Saingre <osaingre@gmail.com>
-Oracle
-Orange
-Özgür Kesim <oec-go@kesim.org>
 Padraig Kitterick <padraigkitterick@gmail.com>
 Palm Stone Games
 Paolo Giarrusso <p.giarrusso@gmail.com>
 Paolo Martini <mrtnpaolo@gmail.com>
-Parker Moore <parkrmoore@gmail.com>
 Pascal S. de Kloe <pascal@quies.net>
 Patrick Crosby <patrick@stathat.com>
 Patrick Gavlin <pgavlin@gmail.com>
 Patrick Higgins <patrick.allen.higgins@gmail.com>
-Patrick Lee <pattyshack101@gmail.com>
 Patrick Mézard <patrick@mezard.eu>
 Patrick Mylund Nielsen <patrick@patrickmn.com>
 Patrick Smith <pat42smith@gmail.com>
 Paul A Querna <paul.querna@gmail.com>
 Paul Hammond <paul@paulhammond.org>
 Paul Lalonde <paul.a.lalonde@gmail.com>
-Paul Meyer <paul.meyer@microsoft.com>
-Paul Rosania <paul.rosania@gmail.com>
 Paul Sbarra <Sbarra.Paul@gmail.com>
 Paul Smith <paulsmith@pobox.com> <paulsmith@gmail.com>
 Paul van Brouwershaven <paul@vanbrouwershaven.com>
-Paulo Casaretto <pcasaretto@gmail.com>
-Pavel Paulau <pavel.paulau@gmail.com>
 Pavel Zinovkin <pavel.zinovkin@gmail.com>
-Pawel Knap <pawelknap88@gmail.com>
 Percy Wegmann <ox.to.a.cart@gmail.com>
-Perry Abbott <perry.j.abbott@gmail.com>
 Petar Maymounkov <petarm@gmail.com>
 Peter Armitage <peter.armitage@gmail.com>
 Peter Froehlich <peter.hans.froehlich@gmail.com>
@@ -686,101 +441,57 @@ Péter Szilágyi <peterke@gmail.com>
 Peter Waldschmidt <peter@waldschmidt.com>
 Peter Waller <peter.waller@gmail.com>
 Peter Williams <pwil3058@gmail.com>
-Philip Børgesen <philip.borgesen@gmail.com>
-Philip Hofer <phofer@umich.edu>
 Philip K. Warren <pkwarren@gmail.com>
-Pierre Durand <pierredurand@gmail.com>
-Pierre Roullon <pierre.roullon@gmail.com>
 Pieter Droogendijk <pieter@binky.org.uk>
 Pietro Gagliardi <pietro10@mac.com>
-Prashant Varanasi <prashant@prashantv.com>
 Preetam Jinka <pj@preet.am>
-Quan Tran <qeed.quan@gmail.com>
 Quan Yong Zhai <qyzhai@gmail.com>
-Quentin Perez <qperez@ocs.online.net>
 Quoc-Viet Nguyen <afelion@gmail.com>
-RackTop Systems Inc.
-Radu Berinde <radu@cockroachlabs.com>
-Rafal Jeczalik <rjeczalik@gmail.com>
 Raif S. Naffah <go@naffah-raif.name>
 Rajat Goel <rajat.goel2010@gmail.com>
-Ralph Corderoy <ralph@inputplus.co.uk>
-Raphael Geronimi <raphael.geronimi@gmail.com>
 Red Hat, Inc.
-Reinaldo de Souza Jr <juniorz@gmail.com>
 Rémy Oudompheng <oudomphe@phare.normalesup.org>
-Ricardo Padilha <ricardospadilha@gmail.com>
 Richard Barnes <rlb@ipv.sx>
 Richard Crowley <r@rcrowley.org>
 Richard Eric Gavaletz <gavaletz@gmail.com>
-Richard Gibson <richard.gibson@gmail.com>
-Richard Miller <miller.research@gmail.com>
 Richard Musiol <mail@richard-musiol.de>
 Rick Arnold <rickarnoldjr@gmail.com>
 Risto Jaakko Saarelma <rsaarelm@gmail.com>
-Rob Norman <rob.norman@infinitycloud.com>
 Robert Daniel Kortschak <dan.kortschak@adelaide.edu.au>
 Robert Dinu <r@varp.se>
 Robert Figueiredo <robfig@gmail.com>
 Robert Hencke <robert.hencke@gmail.com>
 Robert Obryk <robryk@gmail.com>
-Robert Stepanek <robert.stepanek@gmail.com>
 Robin Eklind <r.eklind.87@gmail.com>
 Rodrigo Moraes de Oliveira <rodrigo.moraes@gmail.com>
 Rodrigo Rafael Monti Kochenburger <divoxx@gmail.com>
 Roger Pau Monné <royger@gmail.com>
 Roger Peppe <rogpeppe@gmail.com>
-Roland Shoemaker <rolandshoemaker@gmail.com>
 Ron Hashimoto <mail@h2so5.net>
 Ron Minnich <rminnich@gmail.com>
 Ross Light <rlight2@gmail.com>
 Rowan Worth <sqweek@gmail.com>
-Russell Haering <russellhaering@gmail.com>
-Ryan Bagwell <ryanbagwell@outlook.com>
 Ryan Hitchman <hitchmanr@gmail.com>
-Ryan Lower <rpjlower@gmail.com>
 Ryan Seys <ryan@ryanseys.com>
 Ryan Slade <ryanslade@gmail.com>
-Ryuzo Yamamoto <ryuzo.yamamoto@gmail.com>
 S.Çağlar Onur <caglar@10ur.org>
-Salmān Aljammāz <s@0x65.net>
-Sam Hug <samuel.b.hug@gmail.com>
-Sam Whited <sam@samwhited.com>
-Samuele Pedroni <pedronis@lucediurna.net>
 Sanjay Menakuru <balasanjay@gmail.com>
-Sasha Sobol <sasha@scaledinference.com>
 Scott Barron <scott.barron@github.com>
-Scott Bell <scott@sctsm.com>
 Scott Ferguson <scottwferg@gmail.com>
 Scott Lawrence <bytbox@gmail.com>
-Sean Rees <sean@erifax.org>
-Sebastien Binet <seb.binet@gmail.com>
+Sebastien Binet	<seb.binet@gmail.com>
 Sébastien Paolacci <sebastien.paolacci@gmail.com>
 Sergei Skorobogatov <skorobo@rambler.ru>
 Sergey 'SnakE'  Gromov <snake.scaly@gmail.com>
 Sergio Luis O. B. Correia <sergio@correia.cc>
-Seth Hoenig <seth.a.hoenig@gmail.com>
-Seth Vargo <sethvargo@gmail.com>
-Shahar Kohanim <skohanim@gmail.com>
 Shane Hansen <shanemhansen@gmail.com>
-Shaozhen Ding <dsz0111@gmail.com>
 Shawn Smith <shawn.p.smith@gmail.com>
 Shenghou Ma <minux.ma@gmail.com>
-Shinji Tanaka <shinji.tanaka@gmail.com>
 Shivakumar GN <shivakumar.gn@gmail.com>
 Silvan Jegen <s.jegen@gmail.com>
-Simon Jefford <simon.jefford@gmail.com>
-Simon Rawet <simon@rawet.se>
-Simon Thulbourn <simon+github@thulbourn.com>
 Simon Whitehead <chemnova@gmail.com>
-Sina Siadat <siadat@gmail.com>
 Sokolov Yura <funny.falcon@gmail.com>
-Song Gao <song@gao.io>
-Sourcegraph Inc
-Spencer Nelson <s@spenczar.com>
 Spring Mc <heresy.mc@gmail.com>
-Square, Inc.
-Sridhar Venkatakrishnan <sridhar@laddoo.net>
 StalkR <stalkr@stalkr.net>
 Stan Schwertly <stan@schwertly.com>
 Stefan Nilsson <snilsson@nada.kth.se> <trolleriprofessorn@gmail.com>
@@ -788,103 +499,57 @@ Stéphane Travostino <stephane.travostino@gmail.com>
 Stephen McQuay <stephen@mcquay.me>
 Stephen Weinberg <stephen@q5comm.com>
 Steve McCoy <mccoyst@gmail.com>
-Steve Phillips <elimisteve@gmail.com>
 Steve Streeting <steve@stevestreeting.com>
 Steven Elliot Harris <seharris@gmail.com>
 Steven Hartland <steven.hartland@multiplay.co.uk>
 Stripe, Inc.
-Suyash <dextrous93@gmail.com>
 Sven Almgren <sven@tras.se>
-Syohei YOSHIDA <syohex@gmail.com>
 Szabolcs Nagy <nsz@port70.net>
 Tad Glines <tad.glines@gmail.com>
 Taj Khattra <taj.khattra@gmail.com>
-Takeshi YAMANASHI <9.nashi@gmail.com>
-Takuya Ueda <uedatakuya@gmail.com>
-Tal Shprecher <tshprecher@gmail.com>
 Tamir Duberstein <tamird@gmail.com>
 Tarmigan Casebolt <tarmigan@gmail.com>
 Taru Karttunen <taruti@taruti.net>
-Tatsuhiro Tsujikawa <tatsuhiro.t@gmail.com>
-Terrel Shumway <gopher@shumway.us>
 Tetsuo Kiso <tetsuokiso9@gmail.com>
 Thiago Fransosi Farina <thiago.farina@gmail.com>
 Thomas Alan Copeland <talan.copeland@gmail.com>
-Thomas de Zeeuw <thomasdezeeuw@gmail.com>
-Thomas Desrosiers <thomasdesr@gmail.com>
 Thomas Kappler <tkappler@gmail.com>
-Thorben Krueger <thorben.krueger@gmail.com>
-Thordur Bjornsson <thorduri@secnorth.net>
-Tilman Dilo <tilman.dilo@gmail.com>
-Tim Cooijmans <timcooijmans@gmail.com>
-Tim Ebringer <tim.ebringer@gmail.com>
-Tim Henderson <tim.tadh@gmail.com>
 Timo Savola <timo.savola@gmail.com>
 Timo Truyts <alkaloid.btx@gmail.com>
-Timothy Studd <tim@timstudd.com>
 Tobias Columbus <tobias.columbus@gmail.com>
 Todd Neal <todd@tneal.org>
 Tom Heng <zhm20070928@gmail.com>
 Tom Linford <tomlinford@gmail.com>
 Tommy Schaefer <tommy.schaefer@teecom.com>
 Tor Andersson <tor.andersson@gmail.com>
-Tormod Erevik Lea <tormodlea@gmail.com>
-Totoro W <tw19881113@gmail.com>
 Travis Cline <travis.cline@gmail.com>
-Trey Lawrence <lawrence.trey@gmail.com>
-Trey Tacon <ttacon@gmail.com>
-Tristan Colgate <tcolgate@gmail.com>
-Tristan Ooohry <ooohry@gmail.com>
 Tudor Golubenco <tudor.g@gmail.com>
-Tuo Shan <sturbo89@gmail.com>
+Tw <tw19881113@gmail.com>
 Tyler Bunnell <tylerbunnell@gmail.com>
-Tyler Treat <ttreat31@gmail.com>
 Ugorji Nwoke <ugorji@gmail.com>
 Ulf Holm Nielsen <doktor@dyregod.dk>
-Ulrich Kunitz <uli.kunitz@gmail.com>
-Upthere, Inc.
 Uriel Mangado <uriel@berlinblue.org>
-Vadim Grek <vadimprog@gmail.com>
 Vadim Vygonets <unixdj@gmail.com>
-Vendasta
 Vincent Ambo <tazjin@googlemail.com>
 Vincent Batts <vbatts@hashbangbash.com> <vbatts@gmail.com>
 Vincent Vanackere <vincent.vanackere@gmail.com>
 Vinu Rajashekhar <vinutheraj@gmail.com>
-Vishvananda Ishaya <vishvananda@gmail.com>
-Vitor De Mario <vitordemario@gmail.com>
-Vladimir Mihailenco <vladimir.webdev@gmail.com>
 Vladimir Nikishenko <vova616@gmail.com>
-Vladimir Stefanovic <vladimir.stefanovic@imgtec.com>
 Volker Dobler <dr.volker.dobler@gmail.com>
-Weaveworks
 Wei Guangjing <vcc.163@gmail.com>
 Willem van der Schyff <willemvds@gmail.com>
 William Josephson <wjosephson@gmail.com>
 William Orr <will@worrbase.com> <ay1244@gmail.com>
-Wisdom Omuya <deafgoat@gmail.com>
 Xia Bin <snyh@snyh.org>
 Xing Xing <mikespook@gmail.com>
-Xudong Zhang <felixmelon@gmail.com>
-Xuyang Kang <xuyangkang@gmail.com>
-Yahoo Inc.
-Yann Kerhervé <yann.kerherve@gmail.com>
-Yao Zhang <lunaria21@gmail.com>
-Yasuharu Goto <matope.ono@gmail.com>
 Yasuhiro Matsumoto <mattn.jp@gmail.com>
-Yesudeep Mangalapilly <yesudeep@google.com>
 Yissakhar Z. Beck <yissakhar.beck@gmail.com>
 Yo-An Lin <yoanlin93@gmail.com>
 Yongjian Xu <i3dmaster@gmail.com>
-Yorman Arias <cixtords@gmail.com>
 Yoshiyuki Kanno <nekotaroh@gmail.com> <yoshiyuki.kanno@stoic.co.jp>
 Yusuke Kagiwada <block.rxckin.beats@gmail.com>
 Yuusei Kuwana <kuwana@kumama.org>
 Yuval Pavel Zholkover <paulzhol@gmail.com>
-Zac Bergquist <zbergquist99@gmail.com>
-Zemanta d.o.o.
-Zev Goldstein <zev.goldstein@gmail.com>
 Ziad Hatahet <hatahet@gmail.com>
 Zorion Arrizabalaga <zorionk@gmail.com>
-Фахриддин Балтаев <faxriddinjon@gmail.com>
 申习之 <bronze1man@gmail.com>
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -7,11 +7,6 @@ It is the work of hundreds of contributors. We appreciate your help!

 ## Filing issues

-General questions should go to the
-[golang-nuts mailing list](https://groups.google.com/group/golang-nuts) or
-[other forum](https://golang.org/wiki/Questions) instead of the issue tracker.
-The gophers there will answer or ask you to file an issue if you've tripped over a bug.
-
 When filing an issue, make sure to answer these five questions:

 1. What version of Go are you using (`go version`)?
@@ -20,7 +15,8 @@ When filing an issue, make sure to answer these five questions:
 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/).
+General questions should go to the [golang-nuts mailing list](https://groups.google.com/group/golang-nuts) instead of the issue tracker.
+The gophers there will answer or ask you to file an issue if you've tripped over a bug.

 Sensitive security-related issues should be reported to [security@golang.org](mailto:security@golang.org).

@@ -30,9 +26,7 @@ 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.
+(we use [Gerrit](https://code.google.com/p/gerrit/) instead for code review).

 Unless otherwise noted, the Go source files are distributed under
 the BSD-style license found in the LICENSE file.
--- a/464
+++ b/464
--- 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/README.md
+++ b/README.md
@@ -5,37 +5,41 @@ reliable, and efficient software.

 ![Gopher image](doc/gopher/fiveyears.jpg)

+For documentation about how to install and use Go,
+visit https://golang.org/ or load doc/install-source.html
+in your web browser.
+
 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
+Please report issues here: https://golang.org/issue/new

 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.
+##### Please note that we do not use pull requests.
+
+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 file).  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-source.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 https://golang.org/doc/install or doc/install.html for more details.
--- a/2
+++ b/2
@@ -1 +1 @@
-go1.8.3.typealias
+go1.5rc1
--- 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,107 +1,23 @@
-pkg encoding/json, method (*RawMessage) MarshalJSON() ([]uint8, error)
 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
@@ -330,15 +246,86 @@ 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.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/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,6 +244,9 @@ 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
@@ -239,7 +255,8 @@ 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.
+which can automate the creation of Go files <em>before</em>
+the build, such as by running <code>yacc</code>.
 For more advanced build setups, you may 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
--- a/doc/asm.html
+++ b/doc/asm.html
@@ -12,7 +12,7 @@ The document is not comprehensive.

 <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>.
+<a href="http://plan9.bell-labs.com/sys/doc/asm.html">elsewhere</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
@@ -23,7 +23,7 @@ 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.
@@ -176,7 +176,7 @@ 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
 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>.
+<code>a+4(SB)</code> is four bytes past the start of <code>foo</code>.
 </p>

 <p>
@@ -510,13 +510,6 @@ 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>
@@ -621,15 +614,6 @@ These modes accept only 1, 2, 4, and 8 as scale factors.

 </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>
@@ -757,10 +741,10 @@ Addressing modes:

 </ul>

-<h3 id="ppc64">64-bit PowerPC, a.k.a. ppc64</h3>
+<h3 id="ppc64">Power 64, a.k.a. ppc64</h3>

 <p>
-The 64-bit PowerPC port is in an experimental state.
+The Power 64 port is in an experimental state.
 </p>

 <p>
@@ -780,102 +764,6 @@ mode as on the x86, but the only scale allowed is <code>1</code>.

 </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>
--- a/doc/cmd.html
+++ b/doc/cmd.html
@@ -22,6 +22,8 @@ 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>yacc</code>, are accessible only through
+the go <code>tool</code> subcommand.
 </p>

 <p>
@@ -87,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,65 +101,42 @@ 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.
-If you would like to work in a different location, you will need to set
-<code>GOPATH</code> 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
-same path as your Go installation.
+workspace. It is likely the only environment variable you'll need to set
+when developing Go code.
 </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.
+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/work</code> in this document. Note that this must <b>not</b> be the
+same path as your Go installation.
+(Another common setup is to set <code>GOPATH=$HOME</code>.)
 </p>

+<pre>
+$ <b>mkdir $HOME/work</b>
+$ <b>export GOPATH=$HOME/work</b>
+</pre>
+
 <p>
 For convenience, add the workspace's <code>bin</code> subdirectory
 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:
+To learn more about setting up the <code>GOPATH</code> environment variable,
+please see
+<a href="/cmd/go/#hdr-GOPATH_environment_variable"><code>go help gopath</code></a>
 </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
--- 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>
@@ -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>
@@ -93,15 +92,7 @@ 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.
+Sensitive security-related issues should be reported to <a href="mailto:security@golang.org">security@golang.org</a>.
 </p>

 <h3><a href="/doc/contribute.html">Contributing code</a></h3>
--- a/doc/contribute.html
+++ b/doc/contribute.html
@@ -1,12 +1,14 @@
 <!--{
-	"Title": "Contribution Guide"
+	"Title": "Contribution Guidelines"
 }-->

+<h2 id="Introduction">Introduction</h2>
+
 <p>
-The Go project welcomes all contributors. The process of contributing
-to the Go project may be different than many projects you are used to.
-This document is intended as a guide to help you through the contribution
-process. This guide assumes you have a basic understanding of Git and Go.
+This document explains how to contribute changes to the Go project.
+It assumes you have followed the
+<a href="/doc/install/source">installation instructions</a> and
+have <a href="code.html">written and tested your code</a>.
 </p>

 <p>
@@ -14,58 +16,103 @@ process. This guide assumes you have a basic understanding of Git and Go.
 see <a href="gccgo_contribute.html">Contributing to gccgo</a>.)
 </p>

-<p>
-Sensitive security-related issues should be reported to <a href="mailto:security@golang.org">security@golang.org</a>.
-</p>
-
-<h1 id="contributor">Becoming a contributor</h1>
+<h2 id="Design">Discuss your design</h2>

 <p>
-Before you can contribute to the Go project you need to setup a few prerequisites.
-The Go project uses <a href="https://www.gerritcodereview.com/">Gerrit</a>, an open
-source online tool, to perform all code reviews.
-Gerrit uses your email address as a unique identifier.
-The Go project contributing flow is currently configured to work only with Google Accounts.
-You must go through the following process <em>prior to contributing</em>.
-You only need to do this once per Google Account.
-</p>
-
-<h2 id="auth">Configure Git to use Gerrit</h2>
-<p>
-You'll need a web browser and a command line terminal.
-You should already have Git installed.
+The project welcomes submissions but please let everyone know what
+you're working on if you want to change or add to the Go repositories.
 </p>

 <p>
-Gerrit uses Google Accounts for authentication.
-If you don't have a Google Account, you can create an account which
+Before undertaking to write something new for the Go project,
+please <a href="https://golang.org/issue/new">file an issue</a>
+(or claim an <a href="https://golang.org/issues">existing issue</a>).
+Significant changes must go through the
+<a href="https://golang.org/s/proposal-process">change proposal process</a>
+before they can be accepted.
+</p>
+
+<p>
+This process gives everyone a chance to validate the design,
+helps prevent duplication of effort,
+and ensures that the idea fits inside the goals for the language and tools.
+It also checks that the design is sound before code is written;
+the code review tool is not the place for high-level discussions.
+</p>
+
+<p>
+When planning work, please note that the Go project follows a
+<a href="https://golang.org/wiki/Go-Release-Cycle">six-month
+development cycle</a>. The latter half of each cycle is a three-month
+feature freeze during which only bug fixes and doc updates are accepted.
+New work cannot be submitted during a feature freeze.
+</p>
+
+<h2 id="Testing">Testing redux</h2>
+
+<p>
+You've <a href="code.html">written and tested your code</a>, but
+before sending code out for review, run all the tests for the whole
+tree to make sure the changes don't break other packages or programs:
+</p>
+
+<pre>
+$ cd go/src
+$ ./all.bash
+</pre>
+
+<p>
+(To build under Windows use <code>all.bat</code>.)
+</p>
+
+<p>
+After running for a while, the command should print
+"<code>ALL</code> <code>TESTS</code> <code>PASSED</code>".
+</p>
+
+<h2 id="Code_review">Code review</h2>
+
+<p>
+Changes to Go must be reviewed before they are accepted,
+no matter who makes the change.
+A custom git command called <code>git-codereview</code>,
+discussed below, helps manage the code review process through a Google-hosted
+<a href="https://go-review.googlesource.com/">instance</a> of the code review
+system called <a href="https://code.google.com/p/gerrit/">Gerrit</a>.
+</p>
+
+<h3>Set up authentication for code review</h3>
+
+<p>
+Gerrit uses Google Accounts for authentication. If you don't have
+a Google Account, you can create an account which
 <a href="https://www.google.com/accounts/NewAccount">includes
 a new Gmail email account</a> or create an account associated
 <a href="https://accounts.google.com/SignUpWithoutGmail">with your existing
 email address</a>.
 </p>

-<h3>Step 1: Sign in to googlesource and generate a password</h3>
+<p>
+The email address associated with the Google Account you use will be recorded in
+the <a href="https://go.googlesource.com/go/+log/">change log</a>
+and in the <a href="/CONTRIBUTORS">contributors file</a>.
+</p>

 <p>
-Visit <a href="https://go.googlesource.com">go.googlesource.com</a>
+To set up your account in Gerrit, visit
+<a href="https://go.googlesource.com">go.googlesource.com</a>
 and click on "Generate Password" in the page's top right menu bar.
+</p>
+
+<p>
 You will be redirected to accounts.google.com to sign in.
 </p>

-<h3>Step 2: Run the provided script</h3>
 <p>
-After signing in, you are taken to a page on go.googlesource.com with the title "Configure Git".
-This page contains a personalized script which when run locally will configure git
-to have your unique authentication key.
-This key is paired with one generated server side similar to how ssh keys work.
-</p>
-
-<p>
-Copy and run this script locally in your command line terminal.
-(On a Windows computer using cmd you should instead follow the instructions
-in the yellow box to run the command. If you are using git-bash use the same
-script as *nix.)
+Once signed in, you are returned back to go.googlesource.com to "Configure Git".
+Follow the instructions on the page.
+(If you are on a Windows computer, you should instead follow the instructions
+in the yellow box to run the command.)
 </p>

 <p>
@@ -73,25 +120,23 @@ Your secret authentication token is now in a <code>.gitcookie</code> file
 and Git is configured to use this file.
 </p>

-<h3 id="gerrit">Step 3: Register with Gerrit</h3>
+<h3>Register with Gerrit</h3>

 <p>
-Now that you have your authentication token, you need to register your
-account with Gerrit.
-To do this, visit <a href="https://go-review.googlesource.com/login/">
-go-review.googlesource.com/login/</a>.
-Sign in using the same Google Account you used above.
+Now that you have your authentication token,
+you need to register your account with Gerrit.
+To do this, visit
+<a href="https://go-review.googlesource.com/login/">
+go-review.googlesource.com/login/</a>. You will immediately be redirected
+to Google Accounts. Sign in using the same Google Account you used above.
+That is all that is required.
 </p>

-<h2 id="cla">Contributor License Agreement</h2>
-
-<h3 id="which_cla">Which CLA</h3>
-<p>
-Before sending your first change to the Go project
-you must have completed one of the following two CLAs.
-Which CLA you should sign depends on who owns the copyright to your work.
-</p>
+<h3>Contributor License Agreement</h3>

+<p>Gerrit serves as the gatekeeper and uses your e-mail address as the key.
+To send your first change to the Go project from a given address,
+you must have completed one of the contributor license agreements:
 <ul>
 <li>
 If you are the copyright holder, you will need to agree to the
@@ -102,49 +147,30 @@ contributor license agreement</a>, which can be completed online.
 If your organization is the copyright holder, the organization
 will need to agree to the
 <a href="https://developers.google.com/open-source/cla/corporate">corporate
-contributor license agreement</a>.<br>
+contributor license agreement</a>.
+(If the copyright holder for your code has already completed the
+agreement in connection with another Google open source project,
+it does not need to be completed again.)
 </li>
 </ul>

 <p>
-<i>If the copyright holder for your contribution has already completed the
-agreement in connection with another Google open source project,
-it does not need to be completed again.</i>
-</p>
-
-<h3 id="signing_cla">Completing the CLA</h3>
-
-<p>
-You can see your currently signed agreements and sign new ones through the Gerrit
-interface.
-To do this, <a href="https://go-review.googlesource.com/login/">Log into Gerrit</a>,
+You can use the links above to create and sign the contributor license agreement
+or you can show your current agreements and create new ones through the Gerrit
+interface.  <a href="https://go-review.googlesource.com/login/">Log into Gerrit</a>,
 click your name in the upper-right, choose "Settings", then select "Agreements"
-from the topics on the left.
-If you do not have a signed agreement listed here,
+from the topics on the left. If you do not have a signed agreement listed here,
 you can create one by clicking "New Contributor Agreement" and following the steps.
 </p>

 <p>
-If the copyright holder for the code you are submitting changes &mdash; for example,
-if you start contributing code on behalf of a new company &mdash; please send email
-to golang-dev and let us know, so that we can make sure an appropriate agreement is
-completed and update the <code>AUTHORS</code> file.
+This rigmarole only needs to be done for your first submission for each email address.
 </p>

-<span id="Code_review"></span>
-<h1 id="prepare_dev_env">Preparing a Development Environment for Contributing</h1>
+<h3>Install the git-codereview command</h3>

-<h2 id="git-codereview">Setting up Git for submission to Gerrit</h2>
 <p>
-Changes to Go must be reviewed before they are accepted, no matter who makes the change.
-A custom git command called <code>git-codereview</code>, discussed below,
-helps manage the code review process through a Google-hosted
-<a href="https://go-review.googlesource.com/">instance</a> Gerrit.
-</p>
-
-<h3 id="git-codereview_install">Install the git-codereview command</h3>
-<p>
-Install the <code>git-codereview</code> command by running,
+Now install the <code>git-codereview</code> command by running,
 </p>

 <pre>
@@ -165,37 +191,17 @@ prints help text, not an error.
 </p>

 <p>
-On Windows, when using git-bash you must make sure that
-<code>git-codereview.exe</code> is in your git exec-path.
-Run <code>git --exec-path</code> to discover the right location then create a
-symbolic link or simply copy the executible from $GOPATH/bin to this directory.
+Note to Git aficionados: The <code>git-codereview</code> command is not required to
+upload and manage Gerrit code reviews. For those who prefer plain Git, the text
+below gives the Git equivalent of each git-codereview command. If you do use plain
+Git, note that you still need the commit hooks that the git-codereview command
+configures; those hooks add a Gerrit <code>Change-Id</code> line to the commit
+message and check that all Go source files have been formatted with gofmt. Even
+if you intend to use plain Git for daily work, install the hooks in a new Git
+checkout by running <code>git-codereview</code> <code>hooks</code>.
 </p>

-<p>
-<b>Note to Git aficionados:</b>
-The <code>git-codereview</code> command is not required to
-upload and manage Gerrit code reviews.
-For those who prefer plain Git, the text below gives the Git equivalent of
-each git-codereview command.
-</p>
-
-<p>
-If you do use plain Git, note that you still need the commit hooks that the
-git-codereview command configures; those hooks add a Gerrit
-<code>Change-Id</code> line to the commit message and check that all Go source
-files have been formatted with gofmt.
-Even if you intend to use plain Git for
-daily work, install the hooks in a new Git checkout by running
-<code>git-codereview</code> <code>hooks</code>.
-</p>
-
-<p>
-The workflow described below assumes a single change per branch.
-It is also possible to prepare a sequence of (usually related) changes in a single branch.
-See the <a href="https://golang.org/x/review/git-codereview">git-codereview documentation</a> for details.
-</p>
-
-<h3 id="git-config">Set up git aliases</h3>
+<h3>Set up git aliases</h3>

 <p>
 The <code>git-codereview</code> command can be run directly from the shell
@@ -237,8 +243,7 @@ To install them, copy this text into your Git configuration file
 	sync = codereview sync
 </pre>

-<span id="help"></span>
-<h3 id="understanding_git-codereview">Understanding the git-codereview command</h3>
+<h3>Understanding the git-codereview command</h3>

 <p>After installing the <code>git-codereview</code> command, you can run</p>

@@ -251,70 +256,11 @@ to learn more about its commands.
 You can also read the <a href="https://godoc.org/golang.org/x/review/git-codereview">command documentation</a>.
 </p>

-
-<h1 id="making_a_contribution">Making a Contribution</h1>
-
-<h2 id="Design">Discuss your design</h2>
-
-<p>
-The project welcomes submissions but please let everyone know what
-you're working on if you want to change or add to the Go repositories.
-</p>
-
-<p>
-Before undertaking to write something new for the Go project,
-please <a href="https://golang.org/issue/new">file an issue</a>
-(or claim an <a href="https://golang.org/issues">existing issue</a>).
-Significant changes must go through the
-<a href="https://golang.org/s/proposal-process">change proposal process</a>
-before they can be accepted.
-</p>
-
-<p>
-This process gives everyone a chance to validate the design,
-helps prevent duplication of effort,
-and ensures that the idea fits inside the goals for the language and tools.
-It also checks that the design is sound before code is written;
-the code review tool is not the place for high-level discussions.
-</p>
-
-<p>
-When planning work, please note that the Go project follows a <a
-href="https://golang.org/wiki/Go-Release-Cycle">six-month development cycle</a>.
-The latter half of each cycle is a three-month feature freeze during
-which only bug fixes and doc updates are accepted. New contributions can be
-sent during a feature freeze but will not be accepted until the freeze thaws.
-</p>
-
-<h2 id="making_a_change">Making a change</h2>
-
-<h3 id="checkout_go">Getting Go Source</h3>
-<p>
-First you need to have a local copy of the source checked out from the correct
-repository.
-As Go builds Go you will also likely need to have a working version
-of Go installed (some documentation changes may not need this).
-This should be a recent version of Go and can be obtained via any package or
-binary distribution or you can build it from source.
-</p>
-
-<p>
-You should checkout the Go source repo anywhere you want as long as it's
-outside of your $GOPATH.
-Go to a directory where you want the source to appear and run the following
-command in a terminal.
-</p>
-
-<pre><code>
-$ git clone https://go.googlesource.com/go
-$ cd go
-</code></pre>
-
-<h3 id="master">Contributing to the main Go tree</h3>
+<h3>Switch to the master branch</h3>

 <p>
 Most Go installations use a release branch, but new changes should
-only be made based on the master branch. <br>
+only be made based on the master branch.
 (They may be applied later to a release branch as part of the release process,
 but most contributors won't do this themselves.)
 Before making a change, make sure you start on the master branch:
@@ -330,61 +276,10 @@ $ git sync
 <code>git</code> <code>pull</code> <code>-r</code>.)
 </p>

-<h3 id="subrepos">Contributing to subrepositories (golang.org/x/...)</h3>
-
-<p>
-If you are contributing a change to a subrepository, obtain the
-Go package using <code>go get</code>. For example, to contribute
-to <code>golang.org/x/oauth2</code>, check out the code by running:
-</p>
-
-<pre>
-$ go get -d golang.org/x/oauth2/...
-</pre>
-
-<p>
-Then, change your directory to the package's source directory
-(<code>$GOPATH/src/golang.org/x/oauth2</code>).
-</p>
-
-<h3 id="change">Make your changes</h3>
-
-<p>
-The entire checked-out tree is editable.
-Make your changes as you see fit ensuring that you create appropriate
-tests along with your changes. Test your changes as you go.
-</p>
-
-<h3 id="copyright">Copyright</h3>
-
-<p>
-Files in the Go repository don't list author names, both to avoid clutter
-and to avoid having to keep the lists up to date.
-Instead, your name will appear in the
-<a href="https://golang.org/change">change log</a> and in the <a
-href="/CONTRIBUTORS"><code>CONTRIBUTORS</code></a> file and perhaps the <a
-href="/AUTHORS"><code>AUTHORS</code></a> file.
-These files are automatically generated from the commit logs perodically.
-The <a href="/AUTHORS"><code>AUTHORS</code></a> file defines who &ldquo;The Go
-Authors&rdquo;&mdash;the copyright holders&mdash;are.
-</p>
-
-<p>New files that you contribute should use the standard copyright header:</p>
-
-<pre>
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-</pre>
-
-<p>
-Files in the repository are copyright the year they are added.
-Do not update the copyright year on files that you change.
-</p>
-
-<h3 id="commit_changes">Commit your changes</h3>
+<h3>Make a change</h3>

 <p>
+The entire checked-out tree is writable.
 Once you have edited files, you must tell Git that they have been modified.
 You must also tell Git about any files that are added, removed, or renamed files.
 These operations are done with the usual Git commands,
@@ -395,19 +290,16 @@ and
 </p>

 <p>
-Once you have the changes queued up, you will want to commit them.
-In the Go contribution workflow this is done with a `git change` command,
-which creates a local branch and commits the changes directly to that local branch.
-</p>
+If you wish to checkpoint your work, or are ready to send the code out for review, run</p>

 <pre>
 $ git change <i>&lt;branch&gt;</i>
 </pre>

 <p>
+from any directory in your Go repository to commit the changes so far.
 The name <i>&lt;branch&gt;</i> is an arbitrary one you choose to identify the
-local branch containing your changes and will not be used elsewhere.
-This is an offline operation and nothing will be sent to the server yet.
+local branch containing your changes.
 </p>

 <p>
@@ -418,11 +310,9 @@ then <code>git</code> <code>commit</code>.)
 </p>

 <p>
-As the `git commit` is the final step, Git will open an editor to ask for a
-commit message.
+Git will open a change description file in your editor.
 (It uses the editor named by the <code>$EDITOR</code> environment variable,
 <code>vi</code> by default.)
-
 The file will look like:
 </p>

@@ -441,14 +331,11 @@ At the beginning of this file is a blank line; replace it
 with a thorough description of your change.
 The first line of the change description is conventionally a one-line
 summary of the change, prefixed by the primary affected package,
-and is used as the subject for code review email.
-It should complete the sentence "This change modifies Go to _____."
-The rest of the description elaborates and should provide context for the
+and is used as the subject for code review mail.
+The rest of the
+description elaborates and should provide context for the
 change and explain what it does.
-Write in complete sentences with correct punctuation, just like
-for your comments in Go.
 If there is a helpful reference, mention it here.
-If you've fixed an issue, reference it by number with a # before it.
 </p>

 <p>
@@ -456,7 +343,7 @@ After editing, the template might now read:
 </p>

 <pre>
-math: improve Sin, Cos and Tan precision for very large arguments
+math: improved Sin, Cos and Tan precision for very large arguments

 The existing implementation has poor numerical properties for
 large arguments, so use the McGillicutty algorithm to improve
@@ -484,7 +371,7 @@ the command and move that file to a different branch.
 <p>
 The special notation "Fixes #159" associates the change with issue 159 in the
 <a href="https://golang.org/issue/159">Go issue tracker</a>.
-When this change is eventually applied, the issue
+When this change is eventually submitted, the issue
 tracker will automatically mark the issue as fixed.
 (There are several such conventions, described in detail in the
 <a href="https://help.github.com/articles/closing-issues-via-commit-messages/">GitHub Issue Tracker documentation</a>.)
@@ -495,13 +382,6 @@ Once you have finished writing the commit message,
 save the file and exit the editor.
 </p>

-<p>
-You must have the $EDITOR environment variable set properly and working properly (exiting cleanly)
-for this operation to succeed.
-If you run into any issues at this step, it's likely your editor isn't exiting cleanly.
-Try setting a different editor in your $EDITOR environment variable.
-</p>
-
 <p>
 If you wish to do more editing, re-stage your changes using
 <code>git</code> <code>add</code>, and then run
@@ -512,8 +392,8 @@ $ git change
 </pre>

 <p>
-to update the change description and incorporate the staged changes.
-The change description contains a <code>Change-Id</code> line near the bottom,
+to update the change description and incorporate the staged changes.  The
+change description contains a <code>Change-Id</code> line near the bottom,
 added by a Git commit hook during the initial
 <code>git</code> <code>change</code>.
 That line is used by Gerrit to match successive uploads of the same change.
@@ -525,44 +405,35 @@ Do not edit or delete it.
 runs <code>git</code> <code>commit</code> <code>--amend</code>.)
 </p>

-<h3 id="Testing">Testing</h3>
+<h3>Mail the change for review</h3>

 <p>
-You've <a href="code.html">written and tested your code</a>, but
-before sending code out for review, run all the tests for the whole
-tree to make sure the changes don't break other packages or programs:
-</p>
-
-<pre>
-$ cd go/src
-$ ./all.bash
-</pre>
-
-<p>
-(To build under Windows use <code>all.bat</code>.)
-</p>
-
-<p>
-After running for a while, the command should print
-</p>
-
-<pre>
-"ALL TESTS PASSED".
-</pre>
-
-<h3 id="mail">Send the change for review</h3>
-
-<p>
-Once the change is ready, send it for review.
-This is similar to a <code>git push</code> in a GitHub style workflow.
-This is done via the mail alias setup earlier which despite its name, doesn't
-directly mail anything, it simply sends the change to Gerrit via git push.
+Once the change is ready, mail it out for review:
 </p>

 <pre>
 $ git mail
 </pre>

+<p>
+You can specify a reviewer or CC interested parties
+using the <code>-r</code> or <code>-cc</code> options.
+Both accept a comma-separated list of email addresses:
+</p>
+
+<pre>
+$ git mail -r joe@golang.org -cc mabel@example.com,math-nuts@swtch.com
+</pre>
+
+<p>
+Unless explicitly told otherwise, such as in the discussion leading
+up to sending in the change list, it's better not to specify a reviewer.
+All changes are automatically CC'ed to the
+<a href="https://groups.google.com/group/golang-codereviews">golang-codereviews@googlegroups.com</a>
+mailing list. If this is your first ever change, there may be a moderation
+delay before it appears on the mailing list, to prevent spam.
+</p>
+
 <p>
 (In Git terms, <code>git</code> <code>mail</code> pushes the local committed
 changes to Gerrit using <code>git</code> <code>push</code> <code>origin</code>
@@ -584,76 +455,7 @@ remote: New Changes:
 remote:   https://go-review.googlesource.com/99999 math: improved Sin, Cos and Tan precision for very large arguments
 </pre>

-<h3>Troubleshooting</h3>
-
-<p>
-The most common way that the <code>git mail</code> command fails is because the
-email address used has not gone through the setup above.
-<br>
-If you see something like...
-</p>
-
-<pre>
-remote: Processing changes: refs: 1, done
-remote:
-remote: ERROR:  In commit ab13517fa29487dcf8b0d48916c51639426c5ee9
-remote: ERROR:  author email address XXXXXXXXXXXXXXXXXXX
-remote: ERROR:  does not match your user account.
-</pre>
-
-<p>
-You need to either add the email address listed to the CLA or set this repo to use
-another email address already approved.
-</p>
-
-<p>
-First let's change the email address for this repo so this doesn't happen again.
-You can change your email address for this repo with the following command:
-</p>
-
-<pre>
-$ git config user.email email@address.com
-</pre>
-
-<p>
-Then change the previous commit to use this alternative email address.
-You can do that with:
-</p>
-
-<pre>
-$ git commit --amend --author="Author Name &lt;email@address.com&gt;"
-</pre>
-
-<p>
-Finally try to resend with:
-</p>
-
-<pre>
-$ git mail
-</pre>
-
-<h3 id="cc">Specifying a reviewer / CCing others</h3>
-
-<p>
-Unless explicitly told otherwise, such as in the discussion leading
-up to sending in the change list, it's better not to specify a reviewer.
-All changes are automatically CC'ed to the
-<a href="https://groups.google.com/group/golang-codereviews">golang-codereviews@googlegroups.com</a>
-mailing list. If this is your first ever change, there may be a moderation
-delay before it appears on the mailing list, to prevent spam.
-</p>
-
-<p>
-You can specify a reviewer or CC interested parties
-using the <code>-r</code> or <code>-cc</code> options.
-Both accept a comma-separated list of email addresses:
-</p>
-
-<pre>
-$ git mail -r joe@golang.org -cc mabel@example.com,math-nuts@swtch.com
-</pre>
-
-<h2 id="review">Going through the review process</h2>
+<h3>Reviewing code</h3>

 <p>
 Running <code>git</code> <code>mail</code> will send an email to you and the
@@ -665,15 +467,7 @@ You must reply through the web interface.
 (Unlike with the old Rietveld review system, replying by mail has no effect.)
 </p>

-<h3 id="revise">Revise and resend</h3>
-
-<p>
-The Go contribution workflow is optimized for iterative revisions based on
-feedback.
-It is rare that an initial contribution will be ready to be applied as is.
-As you revise your contribution and resend Gerrit will retain a history of
-all the changes and comments made in the single URL.
-</p>
+<h3>Revise and upload</h3>

 <p>
 You must respond to review comments through the web interface.
@@ -700,7 +494,7 @@ You can see a list of your pending changes by running <code>git</code>
 <code>change</code> <code><i>&lt;branch&gt;</i></code>.
 </p>

-<h3 id="sync">Synchronize your client</h3>
+<h3>Synchronize your client</h3>

 <p>
 While you were working, others might have submitted changes to the repository.
@@ -716,8 +510,6 @@ $ git sync
 <code>git</code> <code>pull</code> <code>-r</code>.)
 </p>

-<h3 id="resolving_conflicts">Resolving Conflicts</h3>
-
 <p>
 If files you were editing have changed, Git does its best to merge the
 remote changes into your local changes.
@@ -785,7 +577,7 @@ might turn up:
 &lt;&lt;&lt;&lt;&lt;&lt;&lt; HEAD
 	if arg &lt; 1e9 {
 =======
-	if arg &lt; 1e10 {
+	if arg &lh; 1e10 {
 &gt;&gt;&gt;&gt;&gt;&gt;&gt; mcgillicutty
 		largeReduce(arg)
 </pre>
@@ -793,8 +585,8 @@ might turn up:
 <p>
 Git doesn't show it, but suppose the original text that both edits
 started with was 1e8; you changed it to 1e10 and the other change to 1e9,
-so the correct answer might now be 1e10.
-First, edit the section to remove the markers and leave the correct code:
+so the correct answer might now be 1e10.  First, edit the section
+to remove the markers and leave the correct code:
 </p>

 <pre>
@@ -820,16 +612,13 @@ Then run <code>git</code> <code>rebase</code> <code>--continue</code> to
 restore the change commit.
 </p>

-<h3 id="download">Reviewing code by others</h3>
+<h3>Reviewing code by others</h3>

 <p>
-As part of the review process reviewers can propose changes directly (in the
-GitHub workflow this would be someone else attaching commits to a pull request).
-
-You can import these changes proposed by someone else into your local Git repository.
+You can import a change proposed by someone else into your local Git repository.
 On the Gerrit review page, click the "Download ▼" link in the upper right
-corner, copy the "Checkout" command and run it from your local Git repo. It
-should look something like this:
+corner, copy the "Checkout" command and run it from your local Git repo.
+It should look something like this:
 </p>

 <pre>
@@ -840,11 +629,11 @@ $ git fetch https://go.googlesource.com/review refs/changes/21/1221/1 &amp;&amp;
 To revert, change back to the branch you were working in.
 </p>

-<h2 id="submit">Apply the change to the master branch</h2>
+<h3>Submit the change after the review</h3>

 <p>
 After the code has been <code>LGTM</code>'ed, an approver may
-apply it to the master branch using the Gerrit UI.
+submit it to the master branch using the Gerrit UI.
 There is a "Submit" button on the web page for the change
 that appears once the change is approved (marked +2).
 </p>
@@ -856,13 +645,41 @@ and the code review will be updated with a link to the change
 in the repository.
 Since the method used to integrate the changes is "Cherry Pick",
 the commit hashes in the repository will be changed by
-the "Submit" operation.
+the submit operation.
 </p>

-<h2 id="more">More information</h2>
+<h3>More information</h3>

 <p>
-In addition to the information here, the Go community maintains a <a
-href="https://golang.org/wiki/CodeReview">CodeReview</a> wiki page.
+In addition to the information here, the Go community maintains a <a href="https://golang.org/wiki/CodeReview">CodeReview</a> wiki page.
 Feel free to contribute to this page as you learn the review process.
 </p>
+
+<h2 id="copyright">Copyright</h2>
+
+<p>Files in the Go repository don't list author names,
+both to avoid clutter and to avoid having to keep the lists up to date.
+Instead, your name will appear in the
+<a href="https://golang.org/change">change log</a>
+and in the <a href="/CONTRIBUTORS"><code>CONTRIBUTORS</code></a> file
+and perhaps the <a href="/AUTHORS"><code>AUTHORS</code></a> file.
+</p>
+
+<p>The <a href="/CONTRIBUTORS"><code>CONTRIBUTORS</code></a> file
+defines who the Go contributors&mdash;the people&mdash;are;
+the <a href="/AUTHORS"><code>AUTHORS</code></a> file defines
+who &ldquo;The Go Authors&rdquo;&mdash;the copyright holders&mdash;are.
+These files will be periodically updated based on the commit logs.
+
+<p>Code that you contribute should use the standard copyright header:</p>
+
+<pre>
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+</pre>
+
+<p>
+Files in the repository are copyright the year they are added. It is not
+necessary to update the copyright year on files that you change.
+</p>
--- 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/release.html
+++ b/doc/devel/release.html
@@ -12,186 +12,6 @@ git pull
 git checkout <i>release-branch</i>
 </pre>

-<h2 id="policy">Release Policy</h2>
-
-<p>
-Each major Go release obsoletes and ends support for the previous one.
-For example, if Go 1.5 has been released, then it is the current release
-and Go 1.4 and earlier are no longer supported.
-We fix critical problems in the current release as needed by issuing minor revisions
-(for example, Go 1.5.1, Go 1.5.2, and so on).
-</p>
-
-<p>
-As a special case, we issue minor revisions for critical security problems
-in both the current release and the previous release.
-For example, if Go 1.5 is the current release then we will issue minor revisions
-to fix critical security problems in both Go 1.4 and Go 1.5 as they arise.
-See the <a href="/security">security policy</a> for more details.
-</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>
@@ -211,11 +31,6 @@ go1.4.2 (released 2015/02/17) includes bug fixes to the <code>go</code> command,
 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>
@@ -227,17 +42,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>
@@ -251,12 +66,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>

@@ -271,17 +86,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>

@@ -308,7 +123,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.
@@ -327,7 +142,7 @@ 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>
--- a/doc/devel/weekly.html
+++ b/doc/devel/weekly.html
@@ -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)
--- 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>
--- 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>
@@ -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>
@@ -3664,3 +3665,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>

--- a/doc/gccgo_install.html
+++ b/doc/gccgo_install.html
@@ -52,19 +52,6 @@ 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,6 +160,23 @@ 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>
@@ -360,15 +364,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 +380,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 +400,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 +526,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.5.html
+++ b/doc/go1.5.html
@@ -83,8 +83,7 @@ time the release dates more conveniently.
 Due to an oversight, the rule that allowed the element type to be elided from slice literals was not
 applied to map keys.
 This has been <a href="/cl/2591">corrected</a> in Go 1.5.
-An example will make this clear.
-As of Go 1.5, this map literal,
+An example will make this clear: as of Go 1.5, this map literal,
 </p>

 <pre>
@@ -183,7 +182,7 @@ Details of the new collector were presented in a
 <p>
 In Go 1.5, the order in which goroutines are scheduled has been changed.
 The properties of the scheduler were never defined by the language,
-but programs that depend on the scheduling order may be broken
+but programs that depended on the scheduling order may be broken
 by this change.
 We have seen a few (erroneous) programs affected by this change.
 If you have programs that implicitly depend on the scheduling
@@ -195,7 +194,7 @@ Another potentially breaking change is that the runtime now
 sets the default number of threads to run simultaneously,
 defined by <code>GOMAXPROCS</code>, to the number
 of cores available on the CPU.
-In prior releases the default was 1.
+In prior releases it defaulted to 1.
 Programs that do not expect to run with multiple cores may
 break inadvertently.
 They can be updated by removing the restriction or by setting
@@ -237,8 +236,8 @@ is only supported using external linking.
 </p>

 <p>
-Also available as experiments are <code>ppc64</code>
-and <code>ppc64le</code> (64-bit PowerPC, big- and little-endian).
+Also available as experiments are <code>ppc64</code> (IBM Power 64)
+and <code>ppc64le</code> (IBM Power 64, little-endian).
 Both these ports support <code>cgo</code> but
 only with internal linking.
 </p>
@@ -248,8 +247,8 @@ On FreeBSD, Go 1.5 requires FreeBSD 8-STABLE+ because of its new use of the <cod
 </p>

 <p>
-On NaCl, Go 1.5 requires SDK version pepper-41. Later pepper versions are not
-compatible due to the removal of the sRPC subsystem from the NaCl runtime.
+On NaCl, Go 1.5 requires SDK version pepper-39 or above because it now uses the
+<code>get_random_bytes</code> system call.
 </p>

 <p>
@@ -293,7 +292,7 @@ The old names are gone; the new tools are available through the <code>go</code>
 mechanism as <code>go tool compile</code>,
 <code>go tool asm</code>,
 <code>and go tool link</code>.
-Also, the file suffixes <code>.6</code>, <code>.8</code>, etc. for the
+Also, the file suffixes <code>.6</code>, <code>.8</code> etc. for the
 intermediate object files are also gone; now they are just plain <code>.o</code> files.
 </p>

@@ -504,13 +503,6 @@ SWIG support has been updated such that
 now require SWIG 3.0.6 or later.
 </li>

-<li>
-The <code>install</code> subcommand now removes the
-binary created by the <code>build</code> subcommand
-in the source directory, if present,
-to avoid problems having two binaries present in the tree.
-</li>
-
 <li>
 The <code>std</code> (standard library) wildcard package name
 now excludes commands.
@@ -520,7 +512,7 @@ A new <code>cmd</code> wildcard covers the commands.
 <li>
 A new <code>-asmflags</code> build option
 sets flags to pass to the assembler.
-However,
+However, 
 the <code>-ccflags</code> build option has been dropped;
 it was specific to the old, now deleted C compiler .
 </li>
@@ -530,6 +522,14 @@ A new <code>-buildmode</code> build option
 sets the build mode, described above.
 </li>

+<li>
+An <code>-asmflags</code> build option has been added to provide
+flags to the assembler.
+However,
+the <code>-ccflags</code> build option has been dropped;
+it was specific to the old, now deleted C compiler .
+</li>
+
 <li>
 A new <code>-pkgdir</code> build option
 sets the location of installed package archives,
@@ -546,8 +546,8 @@ This acts as a custom replacement for <code>go tool</code>.
 <li>
 The <code>test</code> subcommand now has a <code>-count</code>
 flag to specify how many times to run each test and benchmark.
-The <a href="/pkg/testing/"><code>testing</code></a> package
-does the work here, through the <code>-test.count</code> flag.
+<a href="/pkg/testing/"><code>testing</code></a> package
+does the work here, through by the <code>-test.count</code> flag.
 </li>

 <li>
@@ -823,7 +823,7 @@ method to discard data from the input.
 </li>

 <li>
-In the <a href="/pkg/bytes/"><code>bytes</code></a> package,
+Also in the <a href="/pkg/bytes/"><code>bytes</code></a> package,
 the <a href="/pkg/bytes/#Buffer"><code>Buffer</code></a> type
 now has a <a href="/pkg/bytes/#Buffer.Cap"><code>Cap</code></a> method
 that reports the number of bytes allocated within the buffer.
@@ -960,7 +960,7 @@ also now supports decoding of DWARF line tables.

 <li>
 The <a href="/pkg/debug/elf/"><code>debug/elf</code></a>
-package now has support for the 64-bit PowerPC architecture.
+package now has support for the 64-bit Power architecture.
 </li>

 <li>
@@ -1032,14 +1032,14 @@ To update, run
 In the <a href="/pkg/image/"><code>image</code></a> package,
 the <a href="/pkg/image/#Rectangle"><code>Rectangle</code></a> type
 now implements the <a href="/pkg/image/#Image"><code>Image</code></a> interface,
-so a <code>Rectangle</code> can serve as a mask when drawing.
+mask image when drawing.
 </li>

 <li>
 Also in the <a href="/pkg/image/"><code>image</code></a> package,
 to assist in the handling of some JPEG images,
 there is now support for 4:1:1 and 4:1:0 YCbCr subsampling and basic
-CMYK support, represented by the new <code>image.CMYK</code> struct.
+CMYK support, represented by the new image.CMYK struct.
 </li>

 <li>
@@ -1062,7 +1062,7 @@ Because of the echo property of the old code, the operation
 In Go 1.5, that operation may yield a different value.
 The correct code is, and always was, to select the high 8 bits:
 <code>uint8(r&gt;&gt;8)</code>.
-Incidentally, the <code>image/draw</code> package
+Incidentally, <code>image/draw</code> package
 provides better support for such conversions; see
 <a href="https://blog.golang.org/go-imagedraw-package">this blog post</a>
 for more information.
@@ -1095,8 +1095,9 @@ uses a caller-provided buffer, permitting control of allocation and buffer size.
 The <a href="/pkg/log/"><code>log</code></a> package
 has a new <a href="/pkg/log/#LUTC"><code>LUTC</code></a> flag
 that causes time stamps to be printed in the UTC time zone.
-It also adds a <a href="/pkg/log/#Logger.SetOutput"><code>SetOutput</code></a> method
-for user-created loggers.
+It also adds a <a href="/pkg/log/#SetOutput"><code>SetOutput</code></a> function
+to set the output destination for the standard logger
+and a corresponding method for user-created loggers.
 </li>

 <li>
@@ -1108,7 +1109,7 @@ but now correctly according to the IEEE754 definition of NaNs.
 <li>
 The <a href="/pkg/math/big/"><code>math/big</code></a> package
 adds a new <a href="/pkg/math/big/#Jacobi"><code>Jacobi</code></a>
-function for integers and a new
+function for integers and a new method
 <a href="/pkg/math/big/#Int.ModSqrt"><code>ModSqrt</code></a>
 method for the <a href="/pkg/math/big/#Int"><code>Int</code></a> type.
 </li>
@@ -1200,7 +1201,7 @@ variable.

 <li>
 The <a href="/pkg/net/mail/"><code>net/mail</code></a> package
-adds an <a href="/pkg/net/mail/#AddressParser"><code>AddressParser</code></a>
+adds a <a href="/pkg/net/mail/#AddressParser"><code>AddressParser</code></a>
 type that can parse mail addresses.
 </li>

@@ -1251,11 +1252,11 @@ but is otherwise unnecessary as strings support comparison natively.
 </li>

 <li>
-The <a href="/pkg/sync/#WaitGroup"><code>WaitGroup</code></a> implementation in
+The <a href="/pkg/sync/#WaitGroup"><code>WaitGroup</code></a> function in
 package <a href="/pkg/sync/"><code>sync</code></a>
 now diagnoses code that races a call to <a href="/pkg/sync/#WaitGroup.Add"><code>Add</code></a>
 against a return from <a href="/pkg/sync/#WaitGroup.Wait"><code>Wait</code></a>.
-If it detects this condition, the implementation panics.
+If it detects this condition, <code>WaitGroup</code> panics.
 </li>

 <li>
@@ -1287,7 +1288,7 @@ precision.
 <li>
 Also in the <a href="/pkg/text/template/"><code>text/template</code></a> and
 <a href="/pkg/html/template/"><code>html/template</code></a> packages,
-a new <a href="/pkg/text/template/#Template.Option"><code>Option</code></a> method
+a new <a href="/pkg/text/template/#Option"><code>Option</code></a> type
 allows customization of the behavior of the template during execution.
 The sole implemented option allows control over how a missing key is
 handled when indexing a map.
--- 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.8.txt
+++ b/doc/go1.8.txt
@@ -1,55 +0,0 @@
-This file lists things yet to be moved into go1.8.html or deemed too
-minor to mention. Either way, delete from here when done.
-
-Tools:
-
-go: -buildmode=c-archive now builds PIC on ELF (CL 24180)
-go: mobile pkg dir change, recommend using go list in scripts (CL 24930, CL 27929)
-go, dist: can set default pkg-config tool using PKG_CONFIG env var (CL 29991)
-go: can set secure/insecure GIT schemes using GIT_ALLOW_PROTOCOL env var (CL 30135)
-
-API additions and behavior changes:
-
-cmd/compile, runtime, etc: get rid of constant FP registers (CL 28095)
-cmd/compile, runtime: add go:yeswritebarrierrec pragma (CL 30938)
-cmd/compile/internal/gc: enable new parser by default (CL 27203)
-cmd/compile/internal/syntax: fast Go syntax trees, initial commit (CL 27195)
-cmd/compile: add compiler phase timing (CL 24462)
-cmd/compile: add inline explainer (CL 22782)
-cmd/compile: enable flag-specified dump of specific phase+function (CL 23044)
-
-cmd/internal/obj, cmd/link: darwin dynlink support (CL 29393)
-cmd/internal/objfile: add ppc64/ppc64le disassembler support (CL 9682)
-cmd/link, cmd/go: delay linking of mingwex and mingw32 until very end (CL 26670)
-cmd/link: R_ADDR dynamic relocs for internal PIE (CL 29118)
-cmd/link: add trampolines for too far calls in ppc64x (CL 30850)
-cmd/link: allow internal PIE linking (CL 28543)
-cmd/link: fix -X importpath.name=value when import path needs escaping (CL 31970)
-cmd/link: fix -buildmode=pie / -linkshared combination (CL 28996)
-cmd/link: for -buildmode=exe pass -no-pie to external linker (CL 33106)
-cmd/link: insert trampolines for too-far jumps on ARM (CL 29397)
-cmd/link: non-executable stack support for Solaris (CL 24142)
-cmd/link: put text at address 0x1000000 on darwin/amd64 (CL 32185)
-cmd/link: remove the -shared flag (CL 28852)
-cmd/link: split large elf text sections on ppc64x (CL 27790)
-cmd/link: trampoline support for external linking on ARM (CL 31143)
-cmd/objdump: implement objdump of .o files (CL 24818)
-
-go/build: allow % in ${SRCDIR} expansion for Jenkins (CL 31611)
-go/build: do not record go:binary-only-package if build tags not satisfied (CL 31577)
-go/build: implement default GOPATH (CL 32019)
-
-runtime/race: update race runtime (CL 32160)
-runtime: assume 64kB physical pages on ARM (CL 25021)
-runtime: disable stack rescanning by default (CL 31766)
-runtime: don't call cgocallback from signal handler (CL 30218)
-runtime: fix check for vacuous page boundary rounding (CL 27230)
-runtime: fix map iterator concurrent map check (CL 24749)
-runtime: fix newextram PC passed to race detector (CL 29712)
-runtime: implement unconditional hybrid barrier (CL 31765)
-runtime: include pre-panic/throw logs in core dumps (CL 32013)
-runtime: limit the number of map overflow buckets (CL 25049)
-runtime: pass windows float syscall args via XMM (CL 32173)
-runtime: print sigcode on signal crash (CL 32183)
-runtime: record current PC for SIGPROF on non-Go thread (CL 30252)
-runtime: sleep on CLOCK_MONOTONIC in futexsleep1 on freebsd (CL 30154)
--- a/doc/go_faq.html
+++ b/doc/go_faq.html
@@ -98,7 +98,7 @@ 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>
@@ -271,27 +271,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 +335,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">
@@ -769,29 +745,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>
@@ -907,39 +860,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">
@@ -1094,7 +1014,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>
@@ -1174,12 +1094,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>

@@ -1315,26 +1229,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">
@@ -1738,7 +1637,8 @@ 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
+standard GCC back end. <code>Gc</code> is written in Go using
+<code>yacc</code>/<code>bison</code> for the parser
 and uses a custom loader, also written in Go but
 based on the Plan 9 loader, to generate ELF/Mach-O/PE binaries.
 </p>
@@ -1799,7 +1699,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 2.3 MB, but
 that includes more powerful run-time support and type information.
 </p>

@@ -1876,16 +1776,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>

@@ -1893,9 +1792,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>
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Version of January 31, 2017",
+	"Subtitle": "Version of August 5, 2015",
 	"Path": "/ref/spec"
 }-->

@@ -101,14 +101,15 @@ The following terms are used to denote specific Unicode character classes:
 newline        = /* the Unicode code point U+000A */ .
 unicode_char   = /* an arbitrary Unicode code point except newline */ .
 unicode_letter = /* a Unicode code point classified as "Letter" */ .
-unicode_digit  = /* a Unicode code point classified as "Number, decimal digit" */ .
+unicode_digit  = /* a Unicode code point classified as "Decimal Digit" */ .
 </pre>

 <p>
-In <a href="http://www.unicode.org/versions/Unicode8.0.0/">The Unicode Standard 8.0</a>,
-Section 4.5 "General Category" defines a set of character categories.
-Go treats all characters in any of the Letter categories Lu, Ll, Lt, Lm, or Lo
-as Unicode letters, and those in the Number category Nd as Unicode digits.
+In <a href="http://www.unicode.org/versions/Unicode6.3.0/">The Unicode Standard 6.3</a>,
+Section 4.5 "General Category"
+defines a set of character categories.  Go treats
+those characters in category Lu, Ll, Lt, Lm, or Lo as Unicode letters,
+and those in category Nd as Unicode digits.
 </p>

 <h3 id="Letters_and_digits">Letters and digits</h3>
@@ -557,9 +558,7 @@ and are discussed in that section.
 </p>

 <p>
-Numeric constants represent exact values of arbitrary precision and do not overflow.
-Consequently, there are no constants denoting the IEEE-754 negative zero, infinity,
-and not-a-number values.
+Numeric constants represent values of arbitrary precision and do not overflow.
 </p>

 <p>
@@ -594,6 +593,16 @@ respectively, depending on whether it is a boolean, rune, integer, floating-poin
 complex, or string constant.
 </p>

+<p>
+There are no constants denoting the IEEE-754 infinity and not-a-number values,
+but the <a href="/pkg/math/"><code>math</code> package</a>'s
+<a href="/pkg/math/#Inf">Inf</a>,
+<a href="/pkg/math/#NaN">NaN</a>,
+<a href="/pkg/math/#IsInf">IsInf</a>, and
+<a href="/pkg/math/#IsNaN">IsNaN</a>
+functions return and test for those values at run time.
+</p>
+
 <p>
 Implementation restriction: Although numeric constants have arbitrary
 precision in the language, a compiler may implement them using an
@@ -605,7 +614,7 @@ implementation must:

 	<li>Represent floating-point constants, including the parts of
 	    a complex constant, with a mantissa of at least 256 bits
-	    and a signed binary exponent of at least 16 bits.</li>
+	    and a signed exponent of at least 32 bits.</li>

 	<li>Give an error if unable to represent an integer constant
 	    precisely.</li>
@@ -738,7 +747,7 @@ The method set of any other type <code>T</code> consists of all
 The method set of the corresponding <a href="#Pointer_types">pointer type</a> <code>*T</code>
 is the set of all methods declared with receiver <code>*T</code> or <code>T</code>
 (that is, it also contains the method set of <code>T</code>).
-Further rules apply to structs containing embedded fields, as described
+Further rules apply to structs containing anonymous fields, as described
 in the section on <a href="#Struct_types">struct types</a>.
 Any other type has an empty method set.
 In a method set, each method must have a
@@ -947,16 +956,16 @@ Moreover, the inner slices must be initialized individually.
 <p>
 A struct is a sequence of named elements, called fields, each of which has a
 name and a type. Field names may be specified explicitly (IdentifierList) or
-implicitly (EmbeddedField).
+implicitly (AnonymousField).
 Within a struct, non-<a href="#Blank_identifier">blank</a> field names must
 be <a href="#Uniqueness_of_identifiers">unique</a>.
 </p>

 <pre class="ebnf">
-StructType    = "struct" "{" { FieldDecl ";" } "}" .
-FieldDecl     = (IdentifierList Type | EmbeddedField) [ Tag ] .
-EmbeddedField = [ "*" ] TypeName .
-Tag           = string_lit .
+StructType     = "struct" "{" { FieldDecl ";" } "}" .
+FieldDecl      = (IdentifierList Type | AnonymousField) [ Tag ] .
+AnonymousField = [ "*" ] TypeName .
+Tag            = string_lit .
 </pre>

 <pre>
@@ -974,15 +983,16 @@ struct {
 </pre>

 <p>
-A field declared with a type but no explicit field name is called an <i>embedded field</i>.
-An embedded field must be specified as
+A field declared with a type but no explicit field name is an <i>anonymous field</i>,
+also called an <i>embedded</i> field or an embedding of the type in the struct.
+An embedded type must be specified as
 a type name <code>T</code> or as a pointer to a non-interface type name <code>*T</code>,
 and <code>T</code> itself may not be
 a pointer type. The unqualified type name acts as the field name.
 </p>

 <pre>
-// A struct with four embedded fields of types T1, *T2, P.T3 and *P.T4
+// A struct with four anonymous fields of type T1, *T2, P.T3 and *P.T4
 struct {
 	T1        // field name is T1
 	*T2       // field name is T2
@@ -999,15 +1009,15 @@ in a struct type:

 <pre>
 struct {
-	T     // conflicts with embedded field *T and *P.T
-	*T    // conflicts with embedded field T and *P.T
-	*P.T  // conflicts with embedded field T and *T
+	T     // conflicts with anonymous field *T and *P.T
+	*T    // conflicts with anonymous field T and *P.T
+	*P.T  // conflicts with anonymous field T and *T
 }
 </pre>

 <p>
 A field or <a href="#Method_declarations">method</a> <code>f</code> of an
-embedded field in a struct <code>x</code> is called <i>promoted</i> if
+anonymous field in a struct <code>x</code> is called <i>promoted</i> if
 <code>x.f</code> is a legal <a href="#Selectors">selector</a> that denotes
 that field or method <code>f</code>.
 </p>
@@ -1024,7 +1034,7 @@ promoted methods are included in the method set of the struct as follows:
 </p>
 <ul>
 	<li>
-	If <code>S</code> contains an embedded field <code>T</code>,
+	If <code>S</code> contains an anonymous field <code>T</code>,
 	the <a href="#Method_sets">method sets</a> of <code>S</code>
 	and <code>*S</code> both include promoted methods with receiver
 	<code>T</code>. The method set of <code>*S</code> also
@@ -1032,7 +1042,7 @@ promoted methods are included in the method set of the struct as follows:
 	</li>

 	<li>
-	If <code>S</code> contains an embedded field <code>*T</code>,
+	If <code>S</code> contains an anonymous field <code>*T</code>,
 	the method sets of <code>S</code> and <code>*S</code> both
 	include promoted methods with receiver <code>T</code> or
 	<code>*T</code>.
@@ -1042,25 +1052,19 @@ promoted methods are included in the method set of the struct as follows:
 <p>
 A field declaration may be followed by an optional string literal <i>tag</i>,
 which becomes an attribute for all the fields in the corresponding
-field declaration. An empty tag string is equivalent to an absent tag.
-The tags are made visible through a <a href="/pkg/reflect/#StructTag">reflection interface</a>
+field declaration. The tags are made
+visible through a <a href="/pkg/reflect/#StructTag">reflection interface</a>
 and take part in <a href="#Type_identity">type identity</a> for structs
 but are otherwise ignored.
 </p>

 <pre>
+// A struct corresponding to the TimeStamp protocol buffer.
+// The tag strings define the protocol buffer field numbers.
 struct {
-	x, y float64 ""  // an empty tag string is like an absent tag
-	name string  "any string is permitted as a tag"
-	_    [4]byte "ceci n'est pas un champ de structure"
-}
-
-// A struct corresponding to a TimeStamp protocol buffer.
-// The tag strings define the protocol buffer field numbers;
-// they follow the convention outlined by the reflect package.
-struct {
-	microsec  uint64 `protobuf:"1"`
-	serverIP6 uint64 `protobuf:"2"`
+	microsec  uint64 "field 1"
+	serverIP6 uint64 "field 2"
+	process   string "field 3"
 }
 </pre>

@@ -1112,7 +1116,7 @@ one unnamed result it may be written as an unparenthesized type.
 </p>

 <p>
-The final incoming parameter in a function signature may have
+The final parameter in a function signature may have
 a type prefixed with <code>...</code>.
 A function with such a parameter is called <i>variadic</i> and
 may be invoked with zero or more arguments for that parameter.
@@ -1433,8 +1437,8 @@ literal structure and corresponding components have identical types. In detail:
 	<li>Two struct types are identical if they have the same sequence of fields,
 	    and if corresponding fields have the same names, and identical types,
 	    and identical tags.
-	    <a href="#Exported_identifiers">Non-exported</a> field names from different
-	    packages are always different.</li>
+	    Two anonymous fields are considered to have the same name. Lower-case field
+	    names from different packages are always different.</li>

 	<li>Two pointer types are identical if they have identical base types.</li>

@@ -1444,9 +1448,8 @@ literal structure and corresponding components have identical types. In detail:
 	    Parameter and result names are not required to match.</li>

 	<li>Two interface types are identical if they have the same set of methods
-	    with the same names and identical function types.
-	    <a href="#Exported_identifiers">Non-exported</a> method names from different
-	    packages are always different. The order of the methods is irrelevant.</li>
+	    with the same names and identical function types. Lower-case method names from
+	    different packages are always different. The order of the methods is irrelevant.</li>

 	<li>Two map types are identical if they have identical key and value types.</li>

@@ -1794,27 +1797,26 @@ It can be used to construct a set of related constants:
 </p>

 <pre>
-const ( // iota is reset to 0
+const (  // iota is reset to 0
 	c0 = iota  // c0 == 0
 	c1 = iota  // c1 == 1
 	c2 = iota  // c2 == 2
 )

-const ( // iota is reset to 0
-	a = 1 &lt;&lt; iota  // a == 1
+const (
+	a = 1 &lt;&lt; iota  // a == 1 (iota has been reset)
 	b = 1 &lt;&lt; iota  // b == 2
-	c = 3          // c == 3  (iota is not used but still incremented)
-	d = 1 &lt;&lt; iota  // d == 8
+	c = 1 &lt;&lt; iota  // c == 4
 )

-const ( // iota is reset to 0
+const (
 	u         = iota * 42  // u == 0     (untyped integer constant)
 	v float64 = iota * 42  // v == 42.0  (float64 constant)
 	w         = iota * 42  // w == 84    (untyped integer constant)
 )

-const x = iota  // x == 0  (iota has been reset)
-const y = iota  // y == 0  (iota has been reset)
+const x = iota  // x == 0 (iota has been reset)
+const y = iota  // y == 0 (iota has been reset)
 </pre>

 <p>
@@ -1891,7 +1893,7 @@ type NewMutex Mutex
 type PtrMutex *Mutex

 // The method set of *PrintableMutex contains the methods
-// Lock and Unlock bound to its embedded field Mutex.
+// Lock and Unlock bound to its anonymous field Mutex.
 type PrintableMutex struct {
 	Mutex
 }
@@ -2006,7 +2008,7 @@ _, y, _ := coord(p)  // coord() returns three values; only interested in y coord
 <p>
 Unlike regular variable declarations, a short variable declaration may <i>redeclare</i>
 variables provided they were originally declared earlier in the same block
-(or the parameter lists if the block is the function body) with the same type,
+(or the parameter lists if the block is the function body) with the same type, 
 and at least one of the non-<a href="#Blank_identifier">blank</a> variables is new.
 As a consequence, redeclaration can only appear in a multi-variable short declaration.
 Redeclaration does not introduce a new variable; it just assigns a new value to the original.
@@ -2089,7 +2091,7 @@ Receiver     = Parameters .

 <p>
 The receiver is specified via an extra parameter section preceding the method
-name. That parameter section must declare a single non-variadic parameter, the receiver.
+name. That parameter section must declare a single parameter, the receiver.
 Its type must be of the form <code>T</code> or <code>*T</code> (possibly using
 parentheses) where <code>T</code> is a type name. The type denoted by <code>T</code> is called
 the receiver <i>base type</i>; it must not be a pointer or interface type and
@@ -2208,8 +2210,9 @@ math.Sin	// denotes the Sin function in package math
 <p>
 Composite literals construct values for structs, arrays, slices, and maps
 and create a new value each time they are evaluated.
-They consist of the type of the literal followed by a brace-bound list of elements.
-Each element may optionally be preceded by a corresponding key.
+They consist of the type of the value
+followed by a brace-bound list of composite elements. An element may be
+a single expression or a key-value pair.
 </p>

 <pre class="ebnf">
@@ -2217,19 +2220,19 @@ CompositeLit  = LiteralType LiteralValue .
 LiteralType   = StructType | ArrayType | "[" "..." "]" ElementType |
                SliceType | MapType | TypeName .
 LiteralValue  = "{" [ ElementList [ "," ] ] "}" .
-ElementList   = KeyedElement { "," KeyedElement } .
-KeyedElement  = [ Key ":" ] Element .
+ElementList   = Element { "," Element } .
+Element       = [ Key ":" ] Value .
 Key           = FieldName | Expression | LiteralValue .
 FieldName     = identifier .
-Element       = Expression | LiteralValue .
+Value         = Expression | LiteralValue .
 </pre>

 <p>
-The LiteralType's underlying type must be a struct, array, slice, or map type
+The LiteralType must be a struct, array, slice, or map type
 (the grammar enforces this constraint except when the type is given
 as a TypeName).
-The types of the elements and keys must be <a href="#Assignability">assignable</a>
-to the respective field, element, and key types of the literal type;
+The types of the expressions must be <a href="#Assignability">assignable</a>
+to the respective field, element, and key types of the LiteralType;
 there is no additional conversion.
 The key is interpreted as a field name for struct literals,
 an index for array and slice literals, and a key for map literals.
@@ -2242,7 +2245,7 @@ constant key value.
 For struct literals the following rules apply:
 </p>
 <ul>
-	<li>A key must be a field name declared in the struct type.
+	<li>A key must be a field name declared in the LiteralType.
 	</li>
 	<li>An element list that does not contain any keys must
 	    list an element for each struct field in the
@@ -2286,10 +2289,8 @@ For array and slice literals the following rules apply:
 	<li>Each element has an associated integer index marking
 	    its position in the array.
 	</li>
-	<li>An element with a key uses the key as its index. The
-	    key must be a non-negative constant representable by
-	    a value of type <code>int</code>; and if it is typed
-	    it must be of integer type.
+	<li>An element with a key uses the key as its index; the
+	    key must be a constant integer expression.
 	</li>
 	<li>An element without a key uses the previous element's index plus one.
 	    If the first element has no key, its index is zero.
@@ -2306,7 +2307,7 @@ var pointer *Point3D = &amp;Point3D{y: 1000}
 </pre>

 <p>
-The length of an array literal is the length specified in the literal type.
+The length of an array literal is the length specified in the LiteralType.
 If fewer elements than the length are provided in the literal, the missing
 elements are set to the zero value for the array element type.
 It is an error to provide elements with index values outside the index range
@@ -2322,7 +2323,7 @@ days := [...]string{"Sat", "Sun"}  // len(days) == 2

 <p>
 A slice literal describes the entire underlying array literal.
-Thus the length and capacity of a slice literal are the maximum
+Thus, the length and capacity of a slice literal are the maximum
 element index plus one. A slice literal has the form
 </p>

@@ -2352,11 +2353,10 @@ the <code>&amp;T</code> when the element or key type is <code>*T</code>.
 [][]int{{1, 2, 3}, {4, 5}}          // same as [][]int{[]int{1, 2, 3}, []int{4, 5}}
 [][]Point{{{0, 1}, {1, 2}}}         // same as [][]Point{[]Point{Point{0, 1}, Point{1, 2}}}
 map[string]Point{"orig": {0, 0}}    // same as map[string]Point{"orig": Point{0, 0}}
-map[Point]string{{0, 0}: "orig"}    // same as map[Point]string{Point{0, 0}: "orig"}

-type PPoint *Point
-[2]*Point{{1.5, -3.5}, {}}          // same as [2]*Point{&amp;Point{1.5, -3.5}, &amp;Point{}}
-[2]PPoint{{1.5, -3.5}, {}}          // same as [2]PPoint{PPoint(&amp;Point{1.5, -3.5}), PPoint(&amp;Point{})}
+[...]*Point{{1.5, -3.5}, {0, 0}}    // same as [...]*Point{&amp;Point{1.5, -3.5}, &amp;Point{0, 0}}
+
+map[Point]string{{0, 0}: "orig"}    // same as map[Point]string{Point{0, 0}: "orig"}
 </pre>

 <p>
@@ -2446,8 +2446,9 @@ PrimaryExpr =

 Selector       = "." identifier .
 Index          = "[" Expression "]" .
-Slice          = "[" [ Expression ] ":" [ Expression ] "]" |
-                 "[" [ Expression ] ":" Expression ":" Expression "]" .
+Slice          = "[" ( [ Expression ] ":" [ Expression ] ) |
+                     ( [ Expression ] ":" Expression ":" Expression )
+                 "]" .
 TypeAssertion  = "." "(" Type ")" .
 Arguments      = "(" [ ( ExpressionList | Type [ "," ExpressionList ] ) [ "..." ] [ "," ] ] ")" .
 </pre>
@@ -2492,13 +2493,13 @@ If <code>x</code> is a package name, see the section on
 A selector <code>f</code> may denote a field or method <code>f</code> of
 a type <code>T</code>, or it may refer
 to a field or method <code>f</code> of a nested
-<a href="#Struct_types">embedded field</a> of <code>T</code>.
-The number of embedded fields traversed
+<a href="#Struct_types">anonymous field</a> of <code>T</code>.
+The number of anonymous fields traversed
 to reach <code>f</code> is called its <i>depth</i> in <code>T</code>.
 The depth of a field or method <code>f</code>
 declared in <code>T</code> is zero.
 The depth of a field or method <code>f</code> declared in
-an embedded field <code>A</code> in <code>T</code> is the
+an anonymous field <code>A</code> in <code>T</code> is the
 depth of <code>f</code> in <code>A</code> plus one.
 </p>

@@ -2936,7 +2937,6 @@ used in an <a href="#Assignments">assignment</a> or initialization of the specia
 v, ok = a[x]
 v, ok := a[x]
 var v, ok = a[x]
-var v, ok T = a[x]
 </pre>

 <p>
@@ -3117,16 +3117,13 @@ known to be <code>T</code> in a correct program.
 </p>

 <pre>
-var x interface{} = 7          // x has dynamic type int and value 7
-i := x.(int)                   // i has type int and value 7
+var x interface{} = 7  // x has dynamic type int and value 7
+i := x.(int)           // i has type int and value 7

 type I interface { m() }
-
-func f(y I) {
-	s := y.(string)        // illegal: string does not implement I (missing method m)
-	r := y.(io.Reader)     // r has type io.Reader and the dynamic type of y must implement both I and io.Reader
-	…
-}
+var y I
+s := y.(string)        // illegal: string does not implement I (missing method m)
+r := y.(io.Reader)     // r has type io.Reader and y must implement both I and io.Reader
 </pre>

 <p>
@@ -3137,7 +3134,6 @@ A type assertion used in an <a href="#Assignments">assignment</a> or initializat
 v, ok = x.(T)
 v, ok := x.(T)
 var v, ok = x.(T)
-var v, ok T1 = x.(T)
 </pre>

 <p>
@@ -3334,8 +3330,8 @@ var s uint = 33
 var i = 1&lt;&lt;s           // 1 has type int
 var j int32 = 1&lt;&lt;s     // 1 has type int32; j == 0
 var k = uint64(1&lt;&lt;s)   // 1 has type uint64; k == 1&lt;&lt;33
-var m int = 1.0&lt;&lt;s     // 1.0 has type int; m == 0 if ints are 32bits in size
-var n = 1.0&lt;&lt;s == j    // 1.0 has type int32; n == true
+var m int = 1.0&lt;&lt;s     // 1.0 has type int
+var n = 1.0&lt;&lt;s != i    // 1.0 has type int; n == false if ints are 32bits in size
 var o = 1&lt;&lt;s == 2&lt;&lt;s   // 1 and 2 have type int; o == true if ints are 32bits in size
 var p = 1&lt;&lt;s == 1&lt;&lt;33  // illegal if ints are 32bits in size: 1 has type int, but 1&lt;&lt;33 overflows int
 var u = 1.0&lt;&lt;s         // illegal: 1.0 has type float64, cannot shift
@@ -3651,12 +3647,12 @@ is also allowed and follows from the general rules above.
 </p>

 <pre>
-const c = 3 &lt; 4            // c is the untyped boolean constant true
+const c = 3 &lt; 4            // c is the untyped bool constant true

 type MyBool bool
 var x, y int
 var (
-	// The result of a comparison is an untyped boolean.
+	// The result of a comparison is an untyped bool.
 	// The usual assignment rules apply.
 	b3        = x == y // b3 has type bool
 	b4 bool   = x == y // b4 has type bool
@@ -3745,7 +3741,6 @@ A receive expression used in an <a href="#Assignments">assignment</a> or initial
 x, ok = &lt;-ch
 x, ok := &lt;-ch
 var x, ok = &lt;-ch
-var x, ok T = &lt;-ch
 </pre>

 <p>
@@ -3801,8 +3796,7 @@ type <code>T</code> in any of these cases:
 	<code>T</code> is a floating-point type,
 	and <code>x</code> is representable by a value
 	of type <code>T</code> after rounding using
-	IEEE 754 round-to-even rules, but with an IEEE <code>-0.0</code>
-	further rounded to an unsigned <code>0.0</code>.
+	IEEE 754 round-to-even rules.
 	The constant <code>T(x)</code> is the rounded value.
 	</li>
 	<li>
@@ -3822,7 +3816,6 @@ uint(iota)               // iota value of type uint
 float32(2.718281828)     // 2.718281828 of type float32
 complex128(1)            // 1.0 + 0.0i of type complex128
 float32(0.49999999)      // 0.5 of type float32
-float64(-1e-1000)        // 0.0 of type float64
 string('x')              // "x" of type string
 string(0x266c)           // "♬" of type string
 MyString("foo" + "bar")  // "foobar" of type MyString
@@ -3843,12 +3836,10 @@ in any of these cases:
 	to <code>T</code>.
 	</li>
 	<li>
-	ignoring struct tags (see below),
-	<code>x</code>'s type and <code>T</code> have <a href="#Type_identity">identical</a>
+	<code>x</code>'s type and <code>T</code> have identical
 	<a href="#Types">underlying types</a>.
 	</li>
 	<li>
-	ignoring struct tags (see below),
 	<code>x</code>'s type and <code>T</code> are unnamed pointer types
 	and their pointer base types have identical underlying types.
 	</li>
@@ -3868,31 +3859,6 @@ in any of these cases:
 	</li>
 </ul>

-<p>
-<a href="#Struct_types">Struct tags</a> are ignored when comparing struct types
-for identity for the purpose of conversion:
-</p>
-
-<pre>
-type Person struct {
-	Name    string
-	Address *struct {
-		Street string
-		City   string
-	}
-}
-
-var data *struct {
-	Name    string `json:"name"`
-	Address *struct {
-		Street string `json:"street"`
-		City   string `json:"city"`
-	} `json:"address"`
-}
-
-var person = (*Person)(data)  // ignoring tags, the underlying types are identical
-</pre>
-
 <p>
 Specific rules apply to (non-constant) conversions between numeric types or
 to and from a string type.
@@ -4293,7 +4259,7 @@ All other statements are not terminating.

 <p>
 A <a href="#Blocks">statement list</a> ends in a terminating statement if the list
-is not empty and its final non-empty statement is terminating.
+is not empty and its final statement is terminating.
 </p>


@@ -4708,8 +4674,6 @@ Cases then match actual types <code>T</code> against the dynamic type of the
 expression <code>x</code>. As with type assertions, <code>x</code> must be of
 <a href="#Interface_types">interface type</a>, and each non-interface type
 <code>T</code> listed in a case must implement the type of <code>x</code>.
-The types listed in the cases of a type switch must all be
-<a href="#Type_identity">different</a>.
 </p>

 <pre class="ebnf">
@@ -4723,8 +4687,8 @@ TypeList        = Type { "," Type } .
 <p>
 The TypeSwitchGuard may include a
 <a href="#Short_variable_declarations">short variable declaration</a>.
-When that form is used, the variable is declared at the end of the
-TypeSwitchCase in the <a href="#Blocks">implicit block</a> of each clause.
+When that form is used, the variable is declared at the beginning of
+the <a href="#Blocks">implicit block</a> in each clause.
 In clauses with a case listing exactly one type, the variable
 has that type; otherwise, the variable has the type of the expression
 in the TypeSwitchGuard.
@@ -4734,7 +4698,6 @@ in the TypeSwitchGuard.
 The type in a case may be <a href="#Predeclared_identifiers"><code>nil</code></a>;
 that case is used when the expression in the TypeSwitchGuard
 is a <code>nil</code> interface value.
-There may be at most one <code>nil</code> case.
 </p>

 <p>
@@ -4799,8 +4762,8 @@ The "fallthrough" statement is not permitted in a type switch.
 <h3 id="For_statements">For statements</h3>

 <p>
-A "for" statement specifies repeated execution of a block. There are three forms:
-The iteration may be controlled by a single condition, a "for" clause, or a "range" clause.
+A "for" statement specifies repeated execution of a block. The iteration is
+controlled by a condition, a "for" clause, or a "range" clause.
 </p>

 <pre class="ebnf">
@@ -4808,8 +4771,6 @@ ForStmt = "for" [ Condition | ForClause | RangeClause ] Block .
 Condition = Expression .
 </pre>

-<h4 id="For_condition">For statements with single condition</h4>
-
 <p>
 In its simplest form, a "for" statement specifies the repeated execution of
 a block as long as a boolean condition evaluates to true.
@@ -4824,8 +4785,6 @@ for a &lt; b {
 }
 </pre>

-<h4 id="For_clause">For statements with <code>for</code> clause</h4>
-
 <p>
 A "for" statement with a ForClause is also controlled by its condition, but
 additionally it may specify an <i>init</i>
@@ -4864,8 +4823,6 @@ for cond { S() }    is the same as    for ; cond ; { S() }
 for      { S() }    is the same as    for true     { S() }
 </pre>

-<h4 id="For_range">For statements with <code>range</code> clause</h4>
-
 <p>
 A "for" statement with a "range" clause
 iterates through all entries of an array, slice, string or map,
@@ -5373,7 +5330,7 @@ the "for" statement's block but the <code>goto</code> is not.

 <p>
 A "fallthrough" statement transfers control to the first statement of the
-next case clause in an <a href="#Expression_switches">expression "switch" statement</a>.
+next case clause in a <a href="#Expression_switches">expression "switch" statement</a>.
 It may be used only as the final non-empty statement in such a clause.
 </p>

@@ -5765,12 +5722,12 @@ var a = complex(2, -2)             // complex128
 const b = complex(1.0, -1.4)       // untyped complex constant 1 - 1.4i
 x := float32(math.Cos(math.Pi/2))  // float32
 var c64 = complex(5, -x)           // complex64
-var s uint = complex(1, 0)         // untyped complex constant 1 + 0i can be converted to uint
-_ = complex(1, 2&lt;&lt;s)               // illegal: 2 assumes floating-point type, cannot shift
+const s uint = complex(1, 0)       // untyped complex constant 1 + 0i can be converted to uint
+_ = complex(1, 2&lt;&lt;s)               // illegal: 2 has floating-point type, cannot shift
 var rl = real(c64)                 // float32
 var im = imag(a)                   // float64
 const c = imag(b)                  // untyped constant -1.4
-_ = imag(3 &lt;&lt; s)                   // illegal: 3 assumes complex type, cannot shift
+_ = imag(3 &lt;&lt; s)                   // illegal: 3 has complex type, cannot shift
 </pre>

 <h3 id="Handling_panics">Handling panics</h3>
@@ -6201,10 +6158,9 @@ func init() { … }
 </pre>

 <p>
-Multiple such functions may be defined per package, even within a single
-source file. In the package block, the <code>init</code> identifier can
-be used only to declare <code>init</code> functions, yet the identifier
-itself is not <a href="#Declarations_and_scope">declared</a>. Thus
+Multiple such functions may be defined, even within a single
+source file. The <code>init</code> identifier is not
+<a href="#Declarations_and_scope">declared</a> and thus
 <code>init</code> functions cannot be referred to from anywhere
 in a program.
 </p>
--- 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,65 +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.
 </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>
-
-<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>
@@ -67,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
@@ -33,7 +33,7 @@ compiler using the GCC back end, see
 </p>

 <p>
-The Go compilers support eight instruction sets.
+The Go compilers support five instruction sets.
 There are important differences in the quality of the compilers for the different
 architectures.
 </p>
@@ -43,7 +43,9 @@ architectures.
 	<code>amd64</code> (also known as <code>x86-64</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>)
@@ -55,37 +57,19 @@ architectures.
 	<code>arm</code> (<code>ARM</code>)
 </dt>
 <dd>
-	Supports Linux, FreeBSD, NetBSD, OpenBSD and Darwin binaries. Less widely used than the other ports.
+	Supports Linux, FreeBSD, NetBSD 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.
+	Supports Linux and Darwin binaries. New in 1.5 and not as well excercised 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 binaries. New in 1.5 and not as well excercised as other ports.
 </dd>
 </dl>

@@ -103,17 +87,6 @@ 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>
@@ -121,42 +94,27 @@ Go does not support CentOS 6 on these systems.
 <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>.
+chain in <code>$HOME/go1.4</code>.
+(This path may be overridden by setting the <code>GOROOT_BOOTSTRAP</code>
+environment variable.)
 </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.
+Build the tools with Go version 1.4 or a point release (1.4.1, 1.4.2 etc.).
+Go 1.4 binaries can be found at <a href="/dl/">the downloads page</a>.
 </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.
+Download the zip or tarball of Go 1.4 for your platform and extract it to
+<code>$HOME/go1.4</code> (or your nominated <code>GOROOT_BOOTSTRAP</code>
+location).
 </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-20161024.tar.gz">go1.4-bootstrap-20161024.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>.
+If you want to install Go 1.5 on a system that is not supported by Go 1.4 (such
+as <code>linux/ppc64</code>) you can either use
+<a href="/src/bootstrap.bash">bootstrap.bash</a> on a system that can bootstrap Go
+1.5 normally, or bootstrap with gccgo 5.
 </p>

 <p>
@@ -175,9 +133,8 @@ 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:
+To use gccgo, you need to arrange for <code>$GOROOT_BOOSTRAP/bin/go</code> to be
+the go tool that comes as part of gccgo 5. For example on Ubuntu Vivid:
 </p>

 <pre>
@@ -199,40 +156,20 @@ 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.
-</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>.
-</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 clone the repository and check out the latest release tag:</p>

 <pre>
 $ git clone https://go.googlesource.com/go
 $ cd go
-$ git checkout <span class="versionTag"><i>&lt;tag&gt;</i></span>
+$ git checkout go1.5
 </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>

 <p>If you intend to modify the go source code, and
@@ -338,7 +275,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,7 +301,7 @@ $ go get golang.org/x/tools/cmd/godoc
 </pre>

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

@@ -409,7 +346,7 @@ 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>.
+<code>go1.5</code>.
 </p>

 <p>
@@ -419,13 +356,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>
+$ git checkout <i>&lt;tag&gt;</i>
 $ ./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 +374,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 +387,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,24 +399,19 @@ 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>darwin</code> (Mac OS X 10.7 and above and iOS), <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>ppc64le</code> (PowerPC 64-bit, little-endian), and <code>ppc64</code> (PowerPC 64-bit, big-endian).
 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>
@@ -524,18 +454,6 @@ The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
 <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>
@@ -582,7 +500,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>

@@ -643,12 +561,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
@@ -17,7 +17,7 @@
 <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
+Linux, Mac OS X (10.7 and above), and Windows operating systems and
 the 32-bit (<code>386</code>) and 64-bit (<code>amd64</code>) x86 processor
 architectures.
 </p>
@@ -33,11 +33,11 @@ system and architecture, try
 <h2 id="requirements">System requirements</h2>

 <p>
-Go binary distributions 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 +47,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 8-STABLE or later</td> <td>amd64, 386</td> <td>Debian GNU/kFreeBSD not supported</td></tr>
-<tr><td>Linux 2.6.23 or later with glibc</td> <td>amd64, 386, arm, s390x, ppc64le</td> <td>CentOS/RHEL 5.x not supported</td></tr>
-<tr><td>Mac OS X 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>FreeBSD 8-STABLE 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.7 or later</td> <td>amd64</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
@@ -117,12 +117,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>

@@ -219,16 +219,27 @@ and 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 set the <code>GOPATH</code> environment variable;
-see <a href="code.html#Workspaces">How to Write Go Code</a> for details.)
+Create a directory to contain your <a href="code.html#Workspaces">workspace</a>,
+<code>$HOME/work</code> for example, and set the <code>GOPATH</code> environment
+variable to point to that location.
+</p>
+
+<pre>
+$ <b>export GOPATH=$HOME/work</b>
+</pre>
+
+<p>
+You should put the above command in your shell startup script
+(<code>$HOME/.profile</code> for example) or, if you use Windows,
+follow the <a href="#windows_env">instructions above</a> to set the
+<code>GOPATH</code> environment variable on your system.
 </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:
+Next, make the directories <code>src/github.com/user/hello</code> inside your
+workspace (if you use GitHub, substitute your user name for <code>user</code>),
+and inside the <code>hello</code> directory create a file named <code>hello.go</code>
+with the following contents:
 </p>

 <pre>
@@ -242,33 +253,21 @@ func main() {
 </pre>

 <p>
-Then build it with the <code>go</code> tool:
+Then compile 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>
+$ <b>go install github.com/user/hello</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:
+The above command will put an executable command named <code>hello</code> 
+(or <code>hello.exe</code>) inside the <code>bin</code> directory of your workspace.
+Execute the command 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>
+$ <b>$GOPATH/bin/hello</b>
 hello, world
 </pre>

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

-<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.
-</p>
-
 <p>
 Before rushing off to write Go code please read the
 <a href="/doc/code.html">How to Write Go Code</a> document,
@@ -313,10 +306,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/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/json1.go
+++ b/doc/progs/json1.go
@@ -28,7 +28,7 @@ func Encode() {

 	expected := []byte(`{"Name":"Alice","Body":"Hello","Time":1294706395881547000}`)
 	if !reflect.DeepEqual(b, expected) {
-		log.Panicf("Error marshaling %q, expected %q, got %q.", m, expected, b)
+		log.Panicf("Error marshalling %q, expected %q, got %q.", m, expected, b)
 	}

 }
@@ -49,7 +49,7 @@ func Decode() {
 	}

 	if !reflect.DeepEqual(m, expected) {
-		log.Panicf("Error unmarshaling %q, expected %q, got %q.", b, expected, m)
+		log.Panicf("Error unmarshalling %q, expected %q, got %q.", b, expected, m)
 	}

 	m = Message{
@@ -77,7 +77,7 @@ func PartialDecode() {
 	}

 	if !reflect.DeepEqual(expected, m) {
-		log.Panicf("Error unmarshaling %q, expected %q, got %q.", b, expected, m)
+		log.Panicf("Error unmarshalling %q, expected %q, got %q.", b, expected, m)
 	}
 }

--- a/doc/progs/json3.go
+++ b/doc/progs/json3.go
@@ -33,7 +33,7 @@ func Decode() {
 	}

 	if !reflect.DeepEqual(f, expected) {
-		log.Panicf("Error unmarshaling %q, expected %q, got %q", b, expected, f)
+		log.Panicf("Error unmarshalling %q, expected %q, got %q", b, expected, f)
 	}

 	f = map[string]interface{}{
--- a/doc/progs/json4.go
+++ b/doc/progs/json4.go
@@ -36,7 +36,7 @@ func Decode() {
 	}

 	if !reflect.DeepEqual(expected, m) {
-		log.Panicf("Error unmarshaling %q, expected %q, got %q", b, expected, m)
+		log.Panicf("Error unmarshalling %q, expected %q, got %q", b, expected, m)
 	}
 }

--- a/doc/progs/run.go
+++ b/doc/progs/run.go
--- a/doc/root.html
+++ b/doc/root.html
@@ -1,6 +1,5 @@
 <!--{
-	"Path": "/",
-	"Template": true
+	"Path": "/"
 }-->

 <div class="left">
@@ -26,9 +25,7 @@ Hello, 世界
 </div>
 <div class="buttons">
 <a class="run" href="#" title="Run this code [shift-enter]">Run</a>
-{{if $.Share}}
 <a class="share" href="#" title="Share this code">Share</a>
-{{end}}
 <a class="tour" href="//tour.golang.org/" title="Learn Go from your browser">Tour</a>
 </div>
 <div class="toys">
--- a/doc/security.html
+++ b/doc/security.html
@@ -1,174 +0,0 @@
-<!--{
-	"Title": "Go Security Policy",
-	"Path":  "/security",
-	"Template": true
-}-->
-
-<h2>Implementation</h2>
-
-<h3>Reporting a Security Bug</h3>
-
-<p>
-Please report to us any issues you find.
-This document explains how to do that and what to expect in return.
-</p>
-
-<p>
-All security bugs in the Go distribution should be reported by email to
-<a href="mailto:security@golang.org">security@golang.org</a>.
-This mail is delivered to a small security team.
-Your email will be acknowledged within 24 hours, and you'll receive a more
-detailed response to your email within 72 hours indicating the next steps in
-handling your report.
-If you would like, you can encrypt your report using our PGP key (listed below).
-</p>
-
-<p>
-Please use a descriptive subject line for your report email.
-After the initial reply to your report, the security team will endeavor to keep
-you informed of the progress being made towards a fix and full announcement.
-These updates will be sent at least every five days.
-In reality, this is more likely to be every 24-48 hours.
-</p>
-
-<p>
-If you have not received a reply to your email within 48 hours or you have not
-heard from the security team for the past five days please contact the Go
-security team directly:
-</p>
-
-<ul>
-<li>Primary security coordinator: <a href="mailto:adg@golang.org">Andrew Gerrand</a>  (<a href="https://drive.google.com/a/google.com/file/d/0B42ZAZN5yFufRldybEVNandRN2c/view">public key</a>).</li>
-<li>Secondary coordinator: <a href="mailto:agl@golang.org">Adam Langley</a> (<a href="https://www.imperialviolet.org/key.asc">public key</a>).</li>
-<li>If you receive no response, mail <a href="mailto:golang-dev@googlegroups.com">golang-dev@googlegroups.com</a> or use the <a href="https://groups.google.com/forum/#!forum/golang-dev">golang-dev web interface</a>.</li>
-</ul>
-
-<p>
-Please note that golang-dev is a public discussion forum.
-When escalating on this list, please do not disclose the details of the issue.
-Simply state that you're trying to reach a member of the security team.
-</p>
-
-<h3>Flagging Existing Issues as Security-related</h3>
-
-<p>
-If you believe that an <a href="https://golang.org/issue">existing issue</a>
-is security-related, we ask that you send an email to
-<a href="mailto:security@golang.org">security@golang.org</a>.
-The email should include the issue ID and a short description of why it should
-be handled according to this security policy.
-</p>
-
-<h3>Disclosure Process</h3>
-
-<p>The Go project uses the following disclosure process:</p>
-
-<ol>
-<li>Once the security report is received it is assigned a primary handler.
-This person coordinates the fix and release process.</li>
-<li>The issue is confirmed and a list of affected software is determined.</li>
-<li>Code is audited to find any potential similar problems.</li>
-<li>If it is determined, in consultation with the submitter, that a CVE-ID is
-required, the primary handler obtains one via email to
-<a href="http://oss-security.openwall.org/wiki/mailing-lists/distros">oss-distros</a>.</li>
-<li>Fixes are prepared for the two most recent major releases and the head/master
-revision. These fixes are not yet committed to the public repository.</li>
-<li>A notification is sent to the
-<a href="https://groups.google.com/group/golang-announce">golang-announce</a>
-mailing list to give users time to prepare their systems for the update.</li>
-<li>Three working days following this notification, the fixes are applied to
-the <a href="https://go.googlesource.com/go">public repository</a> and a new
-Go release is issued.</li>
-<li>On the date that the fixes are applied, announcements are sent to
-<a href="https://groups.google.com/group/golang-announce">golang-announce</a>,
-<a href="https://groups.google.com/group/golang-dev">golang-dev</a>, and
-<a href="https://groups.google.com/group/golang-nuts">golang-nuts</a>.
-</ol>
-
-<p>
-This process can take some time, especially when coordination is required with
-maintainers of other projects. Every effort will be made to handle the bug in
-as timely a manner as possible, however it's important that we follow the
-process described above to ensure that disclosures are handled consistently.
-</p>
-
-<p>
-For security issues that include the assignment of a CVE-ID,
-the issue is listed publicly under the
-<a href="https://www.cvedetails.com/vulnerability-list/vendor_id-14185/Golang.html">"Golang" product on the CVEDetails website</a>
-as well as the
-<a href="https://web.nvd.nist.gov/view/vuln/search">National Vulnerability Disclosure site</a>.
-</p>
-
-<h3>Receiving Security Updates</h3>
-
-<p>
-The best way to receive security announcements is to subscribe to the
-<a href="https://groups.google.com/forum/#!forum/golang-announce">golang-announce</a>
-mailing list. Any messages pertaining to a security issue will be prefixed
-with <code>[security]</code>.
-</p>
-
-<h3>Comments on This Policy</h3>
-
-<p>
-If you have any suggestions to improve this policy, please send an email to
-<a href="mailto:golang-dev@golang.org">golang-dev@golang.org</a> for discussion.
-</p>
-
-<h3>PGP Key for <a href="mailto:security@golang.org">security@golang.org</a></h3>
-
-<pre>
-----BEGIN PGP PUBLIC KEY BLOCK-----
-Comment: GPGTools - https://gpgtools.org
-
-mQINBFXI1h0BEADZdm05GDFWvjmQKutUVb0cJKS+VR+6XU3g/YQZGC8tnIL6i7te
-+fPJHfQc2uIw0xeBgZX4Ni/S8yIqsbIjqYeaToX7QFUufJDQwrmlQRDVAvvT5HBT
-J80JEs7yHRreFoLzB6dnWehWXzWle4gFKeIy+hvLrYquZVvbeEYTnX7fNzZg0+5L
-ksvj7lnQlJIy1l3sL/7uPr9qsm45/hzd0WjTQS85Ry6Na3tMwRpqGENDh25Blz75
-8JgK9JmtTJa00my1zzeCXU04CKKEMRbkMLozzudOH4ZLiLWcFiKRpeCn860wC8l3
-oJcyyObuTSbr9o05ra3On+epjCEFkknGX1WxPv+TV34i0a23AtuVyTCloKb7RYXc
-7mUaskZpU2rFBqIkzZ4MQJ7RDtGlm5oBy36j2QL63jAZ1cKoT/yvjJNp2ObmWaVF
-X3tk/nYw2H0YDjTkTCgGtyAOj3Cfqrtsa5L0jG5K2p4RY8mtVgQ5EOh7QxuS+rmN
-JiA39SWh7O6uFCwkz/OCXzqeh6/nP10HAb9S9IC34QQxm7Fhd0ZXzEv9IlBTIRzk
-xddSdACPnLE1gJcFHxBd2LTqS/lmAFShCsf8S252kagKJfHRebQJZHCIs6kT9PfE
-0muq6KRKeDXv01afAUvoB4QW/3chUrtgL2HryyO8ugMu7leVGmoZhFkIrQARAQAB
-tCZHbyBTZWN1cml0eSBUZWFtIDxzZWN1cml0eUBnb2xhbmcub3JnPokCPQQTAQoA
-JwUCVcjWHQIbAwUJB4YfgAULCQgHAwUVCgkICwUWAgMBAAIeAQIXgAAKCRA6RtGR
-eVpYOLnDD/9YVTd6DTwdJq6irVfM/ICPlPTXB0JLERqCI1Veptcp56eQoJ0XWGQp
-tkGlgbvmCzFo0B+65Te7YA4R3oyBCXd6JgyWQQPy5p60FHyuuCPVAReclSWyt9f2
-Yj/u4DjghKhELOvPiI96egcU3g9jrEEcPjm7JYkc9M2gVSNOnnJvcD7wpQJNCzon
-51eMZ1ZyfA5UCBTa0SaT9eXg5zwNlYQnB6ZF6TjXezkhLqlTsBuHxoNVf+9vCC0o
-ZKIM2ovptMx9eEguTDKWaQ7tero7Zs/q5fwk/MDzM/LGJ9aXy2RCtqBxv46vDS7G
-fCNq+aPD/wyFd6hxQkvkua6hgZwYT+cJWHYA2Yv0LO3BYOJdjfc+j2hjv+mC9lF0
-UpWhCVJv3hHoFaxnz62GdROzf2wXz6aR9Saj1rYSvqT9jC20VInxqMufXNN2sbpo
-Kyk6MTbAeepphQpfAWQv+ltWgBiEjuFxYdwv/vmw20996JV7O8nqkeCUW84B6su+
-Y3bbdP9o3DBtOT0j9LTB/FucmdNCNHoO+EnNBKJd6FoYTGLWi3Rq9DLx2V9tdJHo
-Bn67dymcl+iyp337HJNY+qS+KCgoqAWlxkzXRiXKb/yluhXdIkqhg4kL8JPAJvfS
-cs7Zn67Mx04ixJnRMYCDmxtD4xPsFMzM7g8m3PQp+nE7WhujM/ImM7kCDQRVyNYd
-ARAAlw9H/1ybQs4K3XKA1joII16rta9KS7ew76+agXo0jeSRwMEQfItOxYvfhmo8
-+ydn5TWsTbifGU8L3+EBTMRRyzWhbaGO0Wizw7BTVJ7n5JW+ndPrcUpp/ilUk6AU
-VxaO/8/R+9+VJZpoeoLHXYloFGNuX58GLIy1jSBvLsLl/Ki5IOrHvD1GK6TftOl5
-j8IPC1LSBrwGJO803x7wUdQP/tsKN/QPR8pnBntrEgrQFSI+Q3qrCvVMmXnBlYum
-jfOBt8pKMgB9/ix+HWN8piQNQiJxD+XjEM6XwUmQqIR7y5GINKWgundCmtYIzVgY
-9p2Br6UPrTJi12LfKv5s2R6NnxFHv/ad29CpPTeLJRsSqFfqBL969BCpj/isXmQE
-m4FtziZidARXo12KiGAnPF9otirNHp4+8hwNB3scf7cI53y8nZivO9cwI7BoClY6
-ZIabjDcJxjK+24emoz3mJ5SHpZpQLSb9o8GbLLfXOq+4uzEX2A30fhrtsQb/x0GM
-4v3EU1aP2mjuksyYbgldtY64tD35wqAA9mVl5Ux+g1HoUBvLw0h+lzwh370NJw//
-ITvBQVUtDMB96rfIP4fL5pYl5pmRz+vsuJ0iXzm05qBgKfSqO7To9SWxQPdX89R4
-u0/XVAlw0Ak9Zceq3W96vseEUTR3aoZCMIPiwfcDaq60rWUAEQEAAYkCJQQYAQoA
-DwUCVcjWHQIbDAUJB4YfgAAKCRA6RtGReVpYOEg/EADZcIYw4q1jAbDkDy3LQG07
-AR8QmLp/RDp72RKbCSIYyvyXEnmrhUg98lUG676qTH+Y7dlEX107dLhFuKEYyV8D
-ZalrFQO/3WpLWdIAmWrj/wq14qii1rgmy96Nh3EqG3CS50HEMGkW1llRx2rgBvGl
-pgoTcwOfT+h8s0HlZdIS/cv2wXqwPgMWr1PIk3as1fu1OH8n/BjeGQQnNJEaoBV7
-El2C/hz3oqf2uYQ1QvpU23F1NrstekxukO8o2Y/fqsgMJqAiNJApUCl/dNhK+W57
-iicjvPirUQk8MUVEHXKhWIzYxon6aEUTx+xyNMBpRJIZlJ61FxtnZhoPiAFtXVPb
-+95BRJA9npidlVFjqz9QDK/4NSnJ3KaERR9tTDcvq4zqT22Z1Ai5gWQKqogTz5Mk
-F+nZwVizW0yi33id9qDpAuApp8o6AiyH5Ql1Bo23bvqS2lMrXPIS/QmPPsA76CBs
-lYjQwwz8abUD1pPdzyYtMKZUMwhicSFOHFDM4oQN16k2KJuntuih8BKVDCzIOq+E
-KHyeh1BqWplUtFh1ckxZlXW9p9F7TsWjtfcKaY8hkX0Cr4uVjwAFIjLcAxk67ROe
-huEb3Gt+lwJz6aNnZUU87ukMAxRVR2LL0btdxgc6z8spl66GXro/LUkXmAdyOEMV
-UDrmjf9pr7o00hC7lCHFzw==
-=WE0r
-----END PGP PUBLIC KEY BLOCK-----
-</pre>
--- a/favicon.ico
+++ b/favicon.ico
--- a/lib/time/update.bash
+++ b/lib/time/update.bash
@@ -1,15 +1,14 @@
-#!/bin/bash
-# Copyright 2012 The Go Authors. All rights reserved.
+#!/bin/sh
+# 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.

 # This script rebuilds the time zone files using files
 # downloaded from the ICANN/IANA distribution.
-# Consult http://www.iana.org/time-zones for the latest versions.

 # Versions to use.
-CODE=2016j
-DATA=2016j
+CODE=2015e
+DATA=2015e

 set -e
 rm -rf work
--- a/lib/time/zoneinfo.zip
+++ b/lib/time/zoneinfo.zip
--- a/misc/android/go_android_exec.go
+++ b/misc/android/go_android_exec.go
@@ -1,4 +1,4 @@
-// Copyright 2014 The Go Authors. All rights reserved.
+// Copyright 2014 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

@@ -91,11 +91,11 @@ func main() {

 	run("shell", "rm", "-rf", deviceGotmp) // Clean up.

-	exitIdx := strings.LastIndex(output, exitstr)
-	if exitIdx == -1 {
+	output = output[strings.LastIndex(output, "\n")+1:]
+	if !strings.HasPrefix(output, exitstr) {
 		log.Fatalf("no exit code: %q", output)
 	}
-	code, err := strconv.Atoi(output[exitIdx+len(exitstr):])
+	code, err := strconv.Atoi(output[len(exitstr):])
 	if err != nil {
 		log.Fatalf("bad exit code: %v", err)
 	}
--- a/misc/arm/a
+++ b/misc/arm/a
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash

-# 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/misc/cgo/errors/err1.go
+++ b/misc/cgo/errors/err1.go
@@ -1,4 +1,4 @@
-// Copyright 2013 The Go Authors. All rights reserved.
+// Copyright 2013 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/misc/cgo/errors/err2.go
+++ b/misc/cgo/errors/err2.go
@@ -1,4 +1,4 @@
-// Copyright 2013 The Go Authors. All rights reserved.
+// Copyright 2013 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/misc/cgo/errors/err3.go
+++ b/misc/cgo/errors/err3.go
@@ -1,4 +1,4 @@
-// Copyright 2014 The Go Authors. All rights reserved.
+// Copyright 2014 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

--- a/misc/cgo/errors/issue11097a.go
+++ b/misc/cgo/errors/issue11097a.go
@@ -1,15 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-/*
-//enum test { foo, bar };
-*/
-import "C"
-
-func main() {
-	var a = C.enum_test(1) // ERROR HERE
-	_ = a
-}
--- a/misc/cgo/errors/issue11097b.go
+++ b/misc/cgo/errors/issue11097b.go
@@ -1,15 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-/*
-//enum test { foo, bar };
-*/
-import "C"
-
-func main() {
-	p := new(C.enum_test) // ERROR HERE
-	_ = p
-}
--- a/misc/cgo/errors/issue13129.go
+++ b/misc/cgo/errors/issue13129.go
@@ -1,14 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// issue 13129: used to output error about C.unsignedshort with CC=clang
-
-package main
-
-import "C"
-
-func main() {
-	var x C.ushort
-	x = int(0) // ERROR HERE
-}
--- a/misc/cgo/errors/issue13423.go
+++ b/misc/cgo/errors/issue13423.go
@@ -1,12 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-// #include <stdio.h>
-import "C"
-
-func main() {
-	_ = C.fopen() // ERROR HERE
-}
--- a/misc/cgo/errors/issue13635.go
+++ b/misc/cgo/errors/issue13635.go
@@ -1,24 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// issue 13635: used to output error about C.unsignedchar.
-// This test tests all such types.
-
-package pkg
-
-import "C"
-
-func main() {
-	var (
-		_ C.uchar         = "uc"  // ERROR HERE
-		_ C.schar         = "sc"  // ERROR HERE
-		_ C.ushort        = "us"  // ERROR HERE
-		_ C.uint          = "ui"  // ERROR HERE
-		_ C.ulong         = "ul"  // ERROR HERE
-		_ C.longlong      = "ll"  // ERROR HERE
-		_ C.ulonglong     = "ull" // ERROR HERE
-		_ C.complexfloat  = "cf"  // ERROR HERE
-		_ C.complexdouble = "cd"  // ERROR HERE
-	)
-}
--- a/misc/cgo/errors/issue13830.go
+++ b/misc/cgo/errors/issue13830.go
@@ -1,26 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// cgo converts C void* to Go unsafe.Pointer, so despite appearances C
-// void** is Go *unsafe.Pointer. This test verifies that we detect the
-// problem at build time.
-
-package main
-
-// typedef void v;
-// void F(v** p) {}
-import "C"
-
-import "unsafe"
-
-type v [0]byte
-
-func f(p **v) {
-	C.F((**C.v)(unsafe.Pointer(p))) // ERROR HERE
-}
-
-func main() {
-	var p *v
-	f(&p)
-}
--- a/misc/cgo/errors/issue14669.go
+++ b/misc/cgo/errors/issue14669.go
@@ -1,23 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Issue 14669: test that fails when build with CGO_CFLAGS selecting
-// optimization.
-
-package p
-
-/*
-const int E = 1;
-
-typedef struct s {
-	int       c;
-} s;
-*/
-import "C"
-
-func F() {
-	_ = C.s{
-		c: C.E,
-	}
-}
--- a/misc/cgo/errors/issue16116.go
+++ b/misc/cgo/errors/issue16116.go
@@ -1,12 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-// void f(void *p, int x) {}
-import "C"
-
-func main() {
-	_ = C.f(1) // ERROR HERE
-}
--- a/misc/cgo/errors/issue16591.go
+++ b/misc/cgo/errors/issue16591.go
@@ -1,17 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Issue 16591: Test that we detect an invalid call that was being
-// hidden by a type conversion inserted by cgo checking.
-
-package p
-
-// void f(int** p) { }
-import "C"
-
-type x *C.int
-
-func F(p *x) {
-	C.f(p) // ERROR HERE
-}
--- a/misc/cgo/errors/issue7757.go
+++ b/misc/cgo/errors/issue7757.go
@@ -1,4 +1,4 @@
-// Copyright 2014 The Go Authors. All rights reserved.
+// Copyright 2014 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

--- a/misc/cgo/errors/issue8442.go
+++ b/misc/cgo/errors/issue8442.go
@@ -1,4 +1,4 @@
-// Copyright 2014 The Go Authors. All rights reserved.
+// Copyright 2014 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

--- a/misc/cgo/errors/malloc.go
+++ b/misc/cgo/errors/malloc.go
@@ -1,34 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Test that C.malloc does not return nil.
-
-package main
-
-// #include <stdlib.h>
-import "C"
-
-import (
-	"fmt"
-	"runtime"
-)
-
-func main() {
-	var size C.size_t
-	size--
-
-	// The Dragonfly libc succeeds when asked to allocate
-	// 0xffffffffffffffff bytes, so pass a different value that
-	// causes it to fail.
-	if runtime.GOOS == "dragonfly" {
-		size = C.size_t(0x7fffffff << (32 * (^uintptr(0) >> 63)))
-	}
-
-	p := C.malloc(size)
-	if p == nil {
-		fmt.Println("malloc: C.malloc returned nil")
-		// Just exit normally--the test script expects this
-		// program to crash, so exiting normally indicates failure.
-	}
-}
--- a/misc/cgo/errors/ptr.go
+++ b/misc/cgo/errors/ptr.go
@@ -1,576 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Tests that cgo detects invalid pointer passing at runtime.
-
-package main
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync"
-)
-
-// ptrTest is the tests without the boilerplate.
-type ptrTest struct {
-	name      string   // for reporting
-	c         string   // the cgo comment
-	imports   []string // a list of imports
-	support   string   // supporting functions
-	body      string   // the body of the main function
-	extra     []extra  // extra files
-	fail      bool     // whether the test should fail
-	expensive bool     // whether the test requires the expensive check
-}
-
-type extra struct {
-	name     string
-	contents string
-}
-
-var ptrTests = []ptrTest{
-	{
-		// Passing a pointer to a struct that contains a Go pointer.
-		name: "ptr1",
-		c:    `typedef struct s { int *p; } s; void f(s *ps) {}`,
-		body: `C.f(&C.s{new(C.int)})`,
-		fail: true,
-	},
-	{
-		// Passing a pointer to a struct that contains a Go pointer.
-		name: "ptr2",
-		c:    `typedef struct s { int *p; } s; void f(s *ps) {}`,
-		body: `p := &C.s{new(C.int)}; C.f(p)`,
-		fail: true,
-	},
-	{
-		// Passing a pointer to an int field of a Go struct
-		// that (irrelevantly) contains a Go pointer.
-		name: "ok1",
-		c:    `struct s { int i; int *p; }; void f(int *p) {}`,
-		body: `p := &C.struct_s{i: 0, p: new(C.int)}; C.f(&p.i)`,
-		fail: false,
-	},
-	{
-		// Passing a pointer to a pointer field of a Go struct.
-		name: "ptr-field",
-		c:    `struct s { int i; int *p; }; void f(int **p) {}`,
-		body: `p := &C.struct_s{i: 0, p: new(C.int)}; C.f(&p.p)`,
-		fail: true,
-	},
-	{
-		// Passing a pointer to a pointer field of a Go
-		// struct, where the field does not contain a Go
-		// pointer, but another field (irrelevantly) does.
-		name: "ptr-field-ok",
-		c:    `struct s { int *p1; int *p2; }; void f(int **p) {}`,
-		body: `p := &C.struct_s{p1: nil, p2: new(C.int)}; C.f(&p.p1)`,
-		fail: false,
-	},
-	{
-		// Passing the address of a slice with no Go pointers.
-		name:    "slice-ok-1",
-		c:       `void f(void **p) {}`,
-		imports: []string{"unsafe"},
-		body:    `s := []unsafe.Pointer{nil}; C.f(&s[0])`,
-		fail:    false,
-	},
-	{
-		// Passing the address of a slice with a Go pointer.
-		name:    "slice-ptr-1",
-		c:       `void f(void **p) {}`,
-		imports: []string{"unsafe"},
-		body:    `i := 0; s := []unsafe.Pointer{unsafe.Pointer(&i)}; C.f(&s[0])`,
-		fail:    true,
-	},
-	{
-		// Passing the address of a slice with a Go pointer,
-		// where we are passing the address of an element that
-		// is not a Go pointer.
-		name:    "slice-ptr-2",
-		c:       `void f(void **p) {}`,
-		imports: []string{"unsafe"},
-		body:    `i := 0; s := []unsafe.Pointer{nil, unsafe.Pointer(&i)}; C.f(&s[0])`,
-		fail:    true,
-	},
-	{
-		// Passing the address of a slice that is an element
-		// in a struct only looks at the slice.
-		name:    "slice-ok-2",
-		c:       `void f(void **p) {}`,
-		imports: []string{"unsafe"},
-		support: `type S struct { p *int; s []unsafe.Pointer }`,
-		body:    `i := 0; p := &S{p:&i, s:[]unsafe.Pointer{nil}}; C.f(&p.s[0])`,
-		fail:    false,
-	},
-	{
-		// Passing the address of a slice of an array that is
-		// an element in a struct, with a type conversion.
-		name:    "slice-ok-3",
-		c:       `void f(void* p) {}`,
-		imports: []string{"unsafe"},
-		support: `type S struct { p *int; a [4]byte }`,
-		body:    `i := 0; p := &S{p:&i}; s := p.a[:]; C.f(unsafe.Pointer(&s[0]))`,
-		fail:    false,
-	},
-	{
-		// Passing the address of a slice of an array that is
-		// an element in a struct, with a type conversion.
-		name:    "slice-ok-4",
-		c:       `typedef void* PV; void f(PV p) {}`,
-		imports: []string{"unsafe"},
-		support: `type S struct { p *int; a [4]byte }`,
-		body:    `i := 0; p := &S{p:&i}; C.f(C.PV(unsafe.Pointer(&p.a[0])))`,
-		fail:    false,
-	},
-	{
-		// Passing the address of a static variable with no
-		// pointers doesn't matter.
-		name:    "varok",
-		c:       `void f(char** parg) {}`,
-		support: `var hello = [...]C.char{'h', 'e', 'l', 'l', 'o'}`,
-		body:    `parg := [1]*C.char{&hello[0]}; C.f(&parg[0])`,
-		fail:    false,
-	},
-	{
-		// Passing the address of a static variable with
-		// pointers does matter.
-		name:    "var",
-		c:       `void f(char*** parg) {}`,
-		support: `var hello = [...]*C.char{new(C.char)}`,
-		body:    `parg := [1]**C.char{&hello[0]}; C.f(&parg[0])`,
-		fail:    true,
-	},
-	{
-		// Storing a Go pointer into C memory should fail.
-		name: "barrier",
-		c: `#include <stdlib.h>
-                    char **f1() { return malloc(sizeof(char*)); }
-                    void f2(char **p) {}`,
-		body:      `p := C.f1(); *p = new(C.char); C.f2(p)`,
-		fail:      true,
-		expensive: true,
-	},
-	{
-		// Storing a Go pointer into C memory by assigning a
-		// large value should fail.
-		name: "barrier-struct",
-		c: `#include <stdlib.h>
-                    struct s { char *a[10]; };
-                    struct s *f1() { return malloc(sizeof(struct s)); }
-                    void f2(struct s *p) {}`,
-		body:      `p := C.f1(); p.a = [10]*C.char{new(C.char)}; C.f2(p)`,
-		fail:      true,
-		expensive: true,
-	},
-	{
-		// Storing a Go pointer into C memory using a slice
-		// copy should fail.
-		name: "barrier-slice",
-		c: `#include <stdlib.h>
-                    struct s { char *a[10]; };
-                    struct s *f1() { return malloc(sizeof(struct s)); }
-                    void f2(struct s *p) {}`,
-		body:      `p := C.f1(); copy(p.a[:], []*C.char{new(C.char)}); C.f2(p)`,
-		fail:      true,
-		expensive: true,
-	},
-	{
-		// A very large value uses a GC program, which is a
-		// different code path.
-		name: "barrier-gcprog-array",
-		c: `#include <stdlib.h>
-                    struct s { char *a[32769]; };
-                    struct s *f1() { return malloc(sizeof(struct s)); }
-                    void f2(struct s *p) {}`,
-		body:      `p := C.f1(); p.a = [32769]*C.char{new(C.char)}; C.f2(p)`,
-		fail:      true,
-		expensive: true,
-	},
-	{
-		// Similar case, with a source on the heap.
-		name: "barrier-gcprog-array-heap",
-		c: `#include <stdlib.h>
-                    struct s { char *a[32769]; };
-                    struct s *f1() { return malloc(sizeof(struct s)); }
-                    void f2(struct s *p) {}
-                    void f3(void *p) {}`,
-		imports:   []string{"unsafe"},
-		body:      `p := C.f1(); n := &[32769]*C.char{new(C.char)}; p.a = *n; C.f2(p); n[0] = nil; C.f3(unsafe.Pointer(n))`,
-		fail:      true,
-		expensive: true,
-	},
-	{
-		// A GC program with a struct.
-		name: "barrier-gcprog-struct",
-		c: `#include <stdlib.h>
-                    struct s { char *a[32769]; };
-                    struct s2 { struct s f; };
-                    struct s2 *f1() { return malloc(sizeof(struct s2)); }
-                    void f2(struct s2 *p) {}`,
-		body:      `p := C.f1(); p.f = C.struct_s{[32769]*C.char{new(C.char)}}; C.f2(p)`,
-		fail:      true,
-		expensive: true,
-	},
-	{
-		// Similar case, with a source on the heap.
-		name: "barrier-gcprog-struct-heap",
-		c: `#include <stdlib.h>
-                    struct s { char *a[32769]; };
-                    struct s2 { struct s f; };
-                    struct s2 *f1() { return malloc(sizeof(struct s2)); }
-                    void f2(struct s2 *p) {}
-                    void f3(void *p) {}`,
-		imports:   []string{"unsafe"},
-		body:      `p := C.f1(); n := &C.struct_s{[32769]*C.char{new(C.char)}}; p.f = *n; C.f2(p); n.a[0] = nil; C.f3(unsafe.Pointer(n))`,
-		fail:      true,
-		expensive: true,
-	},
-	{
-		// Exported functions may not return Go pointers.
-		name: "export1",
-		c:    `extern unsigned char *GoFn();`,
-		support: `//export GoFn
-                          func GoFn() *byte { return new(byte) }`,
-		body: `C.GoFn()`,
-		fail: true,
-	},
-	{
-		// Returning a C pointer is fine.
-		name: "exportok",
-		c: `#include <stdlib.h>
-                    extern unsigned char *GoFn();`,
-		support: `//export GoFn
-                          func GoFn() *byte { return (*byte)(C.malloc(1)) }`,
-		body: `C.GoFn()`,
-	},
-	{
-		// Passing a Go string is fine.
-		name: "pass-string",
-		c: `#include <stddef.h>
-                    typedef struct { const char *p; ptrdiff_t n; } gostring;
-                    gostring f(gostring s) { return s; }`,
-		imports: []string{"unsafe"},
-		body:    `s := "a"; r := C.f(*(*C.gostring)(unsafe.Pointer(&s))); if *(*string)(unsafe.Pointer(&r)) != s { panic(r) }`,
-	},
-	{
-		// Passing a slice of Go strings fails.
-		name:    "pass-string-slice",
-		c:       `void f(void *p) {}`,
-		imports: []string{"strings", "unsafe"},
-		support: `type S struct { a [1]string }`,
-		body:    `s := S{a:[1]string{strings.Repeat("a", 2)}}; C.f(unsafe.Pointer(&s.a[0]))`,
-		fail:    true,
-	},
-	{
-		// Exported functions may not return strings.
-		name:    "ret-string",
-		c:       `extern void f();`,
-		imports: []string{"strings"},
-		support: `//export GoStr
-                          func GoStr() string { return strings.Repeat("a", 2) }`,
-		body: `C.f()`,
-		extra: []extra{
-			{
-				"call.c",
-				`#include <stddef.h>
-                                 typedef struct { const char *p; ptrdiff_t n; } gostring;
-                                 extern gostring GoStr();
-                                 void f() { GoStr(); }`,
-			},
-		},
-		fail: true,
-	},
-	{
-		// Don't check non-pointer data.
-		// Uses unsafe code to get a pointer we shouldn't check.
-		// Although we use unsafe, the uintptr represents an integer
-		// that happens to have the same representation as a pointer;
-		// that is, we are testing something that is not unsafe.
-		name: "ptrdata1",
-		c: `#include <stdlib.h>
-                    void f(void* p) {}`,
-		imports: []string{"unsafe"},
-		support: `type S struct { p *int; a [8*8]byte; u uintptr }`,
-		body:    `i := 0; p := &S{u:uintptr(unsafe.Pointer(&i))}; q := (*S)(C.malloc(C.size_t(unsafe.Sizeof(*p)))); *q = *p; C.f(unsafe.Pointer(q))`,
-		fail:    false,
-	},
-	{
-		// Like ptrdata1, but with a type that uses a GC program.
-		name: "ptrdata2",
-		c: `#include <stdlib.h>
-                    void f(void* p) {}`,
-		imports: []string{"unsafe"},
-		support: `type S struct { p *int; a [32769*8]byte; q *int; u uintptr }`,
-		body:    `i := 0; p := S{u:uintptr(unsafe.Pointer(&i))}; q := (*S)(C.malloc(C.size_t(unsafe.Sizeof(p)))); *q = p; C.f(unsafe.Pointer(q))`,
-		fail:    false,
-	},
-	{
-		// Check deferred pointers when they are used, not
-		// when the defer statement is run.
-		name: "defer",
-		c:    `typedef struct s { int *p; } s; void f(s *ps) {}`,
-		body: `p := &C.s{}; defer C.f(p); p.p = new(C.int)`,
-		fail: true,
-	},
-	{
-		// Check a pointer to a union if the union has any
-		// pointer fields.
-		name:    "union1",
-		c:       `typedef union { char **p; unsigned long i; } u; void f(u *pu) {}`,
-		imports: []string{"unsafe"},
-		body:    `var b C.char; p := &b; C.f((*C.u)(unsafe.Pointer(&p)))`,
-		fail:    true,
-	},
-	{
-		// Don't check a pointer to a union if the union does
-		// not have any pointer fields.
-		// Like ptrdata1 above, the uintptr represents an
-		// integer that happens to have the same
-		// representation as a pointer.
-		name:    "union2",
-		c:       `typedef union { unsigned long i; } u; void f(u *pu) {}`,
-		imports: []string{"unsafe"},
-		body:    `var b C.char; p := &b; C.f((*C.u)(unsafe.Pointer(&p)))`,
-		fail:    false,
-	},
-}
-
-func main() {
-	os.Exit(doTests())
-}
-
-func doTests() int {
-	gopath, err := ioutil.TempDir("", "cgoerrors")
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		return 2
-	}
-	defer os.RemoveAll(gopath)
-
-	if err := os.MkdirAll(filepath.Join(gopath, "src"), 0777); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		return 2
-	}
-
-	workers := runtime.NumCPU() + 1
-
-	var wg sync.WaitGroup
-	c := make(chan int)
-	errs := make(chan int)
-	for i := 0; i < workers; i++ {
-		wg.Add(1)
-		go func() {
-			worker(gopath, c, errs)
-			wg.Done()
-		}()
-	}
-
-	for i := range ptrTests {
-		c <- i
-	}
-	close(c)
-
-	go func() {
-		wg.Wait()
-		close(errs)
-	}()
-
-	tot := 0
-	for e := range errs {
-		tot += e
-	}
-	return tot
-}
-
-func worker(gopath string, c, errs chan int) {
-	e := 0
-	for i := range c {
-		if !doOne(gopath, i) {
-			e++
-		}
-	}
-	if e > 0 {
-		errs <- e
-	}
-}
-
-func doOne(gopath string, i int) bool {
-	t := &ptrTests[i]
-
-	dir := filepath.Join(gopath, "src", fmt.Sprintf("dir%d", i))
-	if err := os.Mkdir(dir, 0777); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		return false
-	}
-
-	name := filepath.Join(dir, fmt.Sprintf("t%d.go", i))
-	f, err := os.Create(name)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		return false
-	}
-
-	b := bufio.NewWriter(f)
-	fmt.Fprintln(b, `package main`)
-	fmt.Fprintln(b)
-	fmt.Fprintln(b, `/*`)
-	fmt.Fprintln(b, t.c)
-	fmt.Fprintln(b, `*/`)
-	fmt.Fprintln(b, `import "C"`)
-	fmt.Fprintln(b)
-	for _, imp := range t.imports {
-		fmt.Fprintln(b, `import "`+imp+`"`)
-	}
-	if len(t.imports) > 0 {
-		fmt.Fprintln(b)
-	}
-	if len(t.support) > 0 {
-		fmt.Fprintln(b, t.support)
-		fmt.Fprintln(b)
-	}
-	fmt.Fprintln(b, `func main() {`)
-	fmt.Fprintln(b, t.body)
-	fmt.Fprintln(b, `}`)
-
-	if err := b.Flush(); err != nil {
-		fmt.Fprintf(os.Stderr, "flushing %s: %v\n", name, err)
-		return false
-	}
-	if err := f.Close(); err != nil {
-		fmt.Fprintf(os.Stderr, "closing %s: %v\n", name, err)
-		return false
-	}
-
-	for _, e := range t.extra {
-		if err := ioutil.WriteFile(filepath.Join(dir, e.name), []byte(e.contents), 0644); err != nil {
-			fmt.Fprintf(os.Stderr, "writing %s: %v\n", e.name, err)
-			return false
-		}
-	}
-
-	ok := true
-
-	cmd := exec.Command("go", "build")
-	cmd.Dir = dir
-	cmd.Env = addEnv("GOPATH", gopath)
-	buf, err := cmd.CombinedOutput()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "test %s failed to build: %v\n%s", t.name, err, buf)
-		return false
-	}
-
-	exe := filepath.Join(dir, filepath.Base(dir))
-	cmd = exec.Command(exe)
-	cmd.Dir = dir
-
-	if t.expensive {
-		cmd.Env = cgocheckEnv("1")
-		buf, err := cmd.CombinedOutput()
-		if err != nil {
-			var errbuf bytes.Buffer
-			if t.fail {
-				fmt.Fprintf(&errbuf, "test %s marked expensive but failed when not expensive: %v\n", t.name, err)
-			} else {
-				fmt.Fprintf(&errbuf, "test %s failed unexpectedly with GODEBUG=cgocheck=1: %v\n", t.name, err)
-			}
-			reportTestOutput(&errbuf, t.name, buf)
-			os.Stderr.Write(errbuf.Bytes())
-			ok = false
-		}
-
-		cmd = exec.Command(exe)
-		cmd.Dir = dir
-	}
-
-	if t.expensive {
-		cmd.Env = cgocheckEnv("2")
-	}
-
-	buf, err = cmd.CombinedOutput()
-
-	if t.fail {
-		if err == nil {
-			var errbuf bytes.Buffer
-			fmt.Fprintf(&errbuf, "test %s did not fail as expected\n", t.name)
-			reportTestOutput(&errbuf, t.name, buf)
-			os.Stderr.Write(errbuf.Bytes())
-			ok = false
-		} else if !bytes.Contains(buf, []byte("Go pointer")) {
-			var errbuf bytes.Buffer
-			fmt.Fprintf(&errbuf, "test %s output does not contain expected error (failed with %v)\n", t.name, err)
-			reportTestOutput(&errbuf, t.name, buf)
-			os.Stderr.Write(errbuf.Bytes())
-			ok = false
-		}
-	} else {
-		if err != nil {
-			var errbuf bytes.Buffer
-			fmt.Fprintf(&errbuf, "test %s failed unexpectedly: %v\n", t.name, err)
-			reportTestOutput(&errbuf, t.name, buf)
-			os.Stderr.Write(errbuf.Bytes())
-			ok = false
-		}
-
-		if !t.expensive && ok {
-			// Make sure it passes with the expensive checks.
-			cmd := exec.Command(exe)
-			cmd.Dir = dir
-			cmd.Env = cgocheckEnv("2")
-			buf, err := cmd.CombinedOutput()
-			if err != nil {
-				var errbuf bytes.Buffer
-				fmt.Fprintf(&errbuf, "test %s failed unexpectedly with expensive checks: %v\n", t.name, err)
-				reportTestOutput(&errbuf, t.name, buf)
-				os.Stderr.Write(errbuf.Bytes())
-				ok = false
-			}
-		}
-	}
-
-	if t.fail && ok {
-		cmd = exec.Command(exe)
-		cmd.Dir = dir
-		cmd.Env = cgocheckEnv("0")
-		buf, err := cmd.CombinedOutput()
-		if err != nil {
-			var errbuf bytes.Buffer
-			fmt.Fprintf(&errbuf, "test %s failed unexpectedly with GODEBUG=cgocheck=0: %v\n", t.name, err)
-			reportTestOutput(&errbuf, t.name, buf)
-			os.Stderr.Write(errbuf.Bytes())
-			ok = false
-		}
-	}
-
-	return ok
-}
-
-func reportTestOutput(w io.Writer, name string, buf []byte) {
-	fmt.Fprintf(w, "=== test %s output ===\n", name)
-	fmt.Fprintf(w, "%s", buf)
-	fmt.Fprintf(w, "=== end of test %s output ===\n", name)
-}
-
-func cgocheckEnv(val string) []string {
-	return addEnv("GODEBUG", "cgocheck="+val)
-}
-
-func addEnv(key, val string) []string {
-	env := []string{key + "=" + val}
-	look := key + "="
-	for _, e := range os.Environ() {
-		if !strings.HasPrefix(e, look) {
-			env = append(env, e)
-		}
-	}
-	return env
-}
--- a/misc/cgo/errors/test.bash
+++ b/misc/cgo/errors/test.bash
@@ -11,27 +11,19 @@ check() {
 		echo 1>&2 misc/cgo/errors/test.bash: BUG: cannot find ERROR HERE in $file
 		exit 1
 	fi
-	expect $file $file:$line:
-}
-
-expect() {
-	file=$1
-	shift
 	if go build $file >errs 2>&1; then
-		echo 1>&2 misc/cgo/errors/test.bash: BUG: expected cgo to fail on $file but it succeeded
+		echo 1>&2 misc/cgo/errors/test.bash: BUG: expected cgo to fail but it succeeded
 		exit 1
 	fi
 	if ! test -s errs; then
-		echo 1>&2 misc/cgo/errors/test.bash: BUG: expected error output for $file but saw none
+		echo 1>&2 misc/cgo/errors/test.bash: BUG: expected error output but saw none
+		exit 1
+	fi
+	if ! fgrep $file:$line: errs >/dev/null 2>&1; then
+		echo 1>&2 misc/cgo/errors/test.bash: BUG: expected error on line $line but saw:
+		cat 1>&2 errs
 		exit 1
 	fi
-	for error; do
-		if ! fgrep $error errs >/dev/null 2>&1; then
-			echo 1>&2 misc/cgo/errors/test.bash: BUG: expected error output for $file to contain \"$error\" but saw:
-			cat 1>&2 errs
-			exit 1
-		fi
-	done
 }

 check err1.go
@@ -39,35 +31,6 @@ check err2.go
 check err3.go
 check issue7757.go
 check issue8442.go
-check issue11097a.go
-check issue11097b.go
-expect issue13129.go C.ushort
-check issue13423.go
-expect issue13635.go C.uchar C.schar C.ushort C.uint C.ulong C.longlong C.ulonglong C.complexfloat C.complexdouble
-check issue13830.go
-check issue16116.go
-check issue16591.go
-
-if ! go build issue14669.go; then
-	exit 1
-fi
-if ! CGO_CFLAGS="-O" go build issue14669.go; then
-	exit 1
-fi
-
-if ! go run ptr.go; then
-	exit 1
-fi
-
-# The malloc.go test should crash.
-rm -f malloc.out
-if go run malloc.go >malloc.out 2>&1; then
-	echo '`go run malloc.go` succeeded unexpectedly'
-	cat malloc.out
-	rm -f malloc.out
-	exit 1
-fi
-rm -f malloc.out

 rm -rf errs _obj
 exit 0
--- a/misc/cgo/fortran/answer.f90
+++ b/misc/cgo/fortran/answer.f90
@@ -1,9 +0,0 @@
-! Copyright 2016 The Go Authors. All rights reserved.
-! Use of this source code is governed by a BSD-style
-! license that can be found in the LICENSE file.
-
-function the_answer() result(j) bind(C)
-  use iso_c_binding, only: c_int
-  integer(c_int) :: j ! output
-  j = 42
-end function the_answer
--- a/misc/cgo/fortran/fortran.go
+++ b/misc/cgo/fortran/fortran.go
@@ -1,12 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package fortran
-
-// int the_answer();
-import "C"
-
-func TheAnswer() int {
-	return int(C.the_answer())
-}
--- a/misc/cgo/fortran/fortran_test.go
+++ b/misc/cgo/fortran/fortran_test.go
@@ -1,13 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package fortran
-
-import "testing"
-
-func TestFortran(t *testing.T) {
-	if a := TheAnswer(); a != 42 {
-		t.Errorf("Unexpected result for The Answer. Got: %d Want: 42", a)
-	}
-}
--- a/misc/cgo/fortran/helloworld/helloworld.f90
+++ b/misc/cgo/fortran/helloworld/helloworld.f90
@@ -1,3 +0,0 @@
-      program HelloWorldF90
-              write(*,*) "Hello World!"
-      end program HelloWorldF90
--- a/misc/cgo/fortran/test.bash
+++ b/misc/cgo/fortran/test.bash
@@ -1,39 +0,0 @@
-#!/usr/bin/env bash
-# Copyright 2016 The Go Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file.
-
-# This directory is intended to test the use of Fortran with cgo.
-
-set -e
-
-FC=$1
-
-goos=$(go env GOOS)
-
-libext="so"
-if [ "$goos" == "darwin" ]; then
-	libext="dylib"
-fi
-
-case "$FC" in
-*gfortran*)
-  libpath=$(dirname $($FC -print-file-name=libgfortran.$libext))
-  export CGO_LDFLAGS="$CGO_LDFLAGS -Wl,-rpath,$libpath -L $libpath"
-  ;;
-esac
-
-if ! $FC helloworld/helloworld.f90 -o main.exe >& /dev/null; then
-  echo "skipping Fortran test: could not build helloworld.f90 with $FC"
-  exit 0
-fi
-rm -f main.exe
-
-status=0
-
-if ! go test; then
-  echo "FAIL: go test"
-  status=1
-fi
-
-exit $status
--- a/misc/cgo/gmp/fib.go
+++ b/misc/cgo/gmp/fib.go
@@ -1,4 +1,4 @@
-// Copyright 2009 The Go Authors. All rights reserved.
+// 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/misc/cgo/gmp/gmp.go
+++ b/misc/cgo/gmp/gmp.go
@@ -1,4 +1,4 @@
-// Copyright 2009 The Go Authors. All rights reserved.
+// 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/misc/cgo/gmp/pi.go
+++ b/misc/cgo/gmp/pi.go
@@ -1,9 +1,42 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
 // +build ignore

+/*
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+    * Neither the name of "The Computer Language Benchmarks Game" nor the
+    name of "The Computer Language Shootout Benchmarks" nor the names of
+    its contributors may be used to endorse or promote products derived
+    from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/* The Computer Language Benchmarks Game
+ * http://shootout.alioth.debian.org/
+ *
+ * contributed by The Go Authors.
+ * based on pidigits.c (by Paolo Bonzini & Sean Bartlett,
+ *                      modified by Michael Mellor)
+ */
+
 package main

 import (
--- a/misc/cgo/life/c-life.c
+++ b/misc/cgo/life/c-life.c
@@ -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/misc/cgo/life/life.go
+++ b/misc/cgo/life/life.go
@@ -1,6 +1,6 @@
 // skip

-// 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/misc/cgo/life/life.h
+++ b/misc/cgo/life/life.h
@@ -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/misc/cgo/life/main.go
+++ b/misc/cgo/life/main.go
@@ -1,10 +1,10 @@
 // cmpout

-// 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.

-// +build test_run
+// +build ignore

 // Run the game of life in C using Go for parallelization.

--- a/misc/cgo/stdio/chain.go
+++ b/misc/cgo/stdio/chain.go
@@ -1,20 +1,19 @@
 // cmpout

-// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

-// +build test_run
+// +build ignore

 // Pass numbers along a chain of threads.

 package main

 import (
+	"../stdio"
 	"runtime"
 	"strconv"
-
-	"../stdio"
 )

 const N = 10
--- a/misc/cgo/stdio/fib.go
+++ b/misc/cgo/stdio/fib.go
@@ -1,10 +1,10 @@
 // cmpout

-// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

-// +build test_run
+// +build ignore

 // Compute Fibonacci numbers with two goroutines
 // that pass integers back and forth.  No actual
@@ -14,10 +14,9 @@
 package main

 import (
+	"../stdio"
 	"runtime"
 	"strconv"
-
-	"../stdio"
 )

 func fibber(c, out chan int64, i int64) {
--- a/misc/cgo/stdio/file.go
+++ b/misc/cgo/stdio/file.go
@@ -1,6 +1,6 @@
 // skip

-// Copyright 2009 The Go Authors. All rights reserved.
+// 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/misc/cgo/stdio/hello.go
+++ b/misc/cgo/stdio/hello.go
@@ -1,10 +1,10 @@
 // cmpout

-// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

-// +build test_run
+// +build ignore

 package main

--- a/misc/cgo/stdio/stdio.go
+++ b/misc/cgo/stdio/stdio.go
@@ -1,6 +1,6 @@
 // skip

-// Copyright 2009 The Go Authors. All rights reserved.
+// 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/misc/cgo/test/api.go
+++ b/misc/cgo/test/api.go
@@ -1,4 +1,4 @@
-// Copyright 2013 The Go Authors. All rights reserved.
+// Copyright 2013 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.

@@ -7,11 +7,6 @@
 package cgotest

 // #include <stdlib.h>
-//
-// // Test for issue 17723.
-// typedef char *cstring_pointer;
-// static void cstring_pointer_fun(cstring_pointer dummy) { }
-//
 // const char *api_hello = "hello!";
 import "C"
 import "unsafe"
@@ -26,5 +21,4 @@ func testAPI() {
 	var b []byte
 	b = C.GoBytes(unsafe.Pointer(C.api_hello), C.int(6))
 	_, _ = s, b
-	C.cstring_pointer_fun(nil)
 }
--- a/misc/cgo/test/basic.go
+++ b/misc/cgo/test/basic.go
@@ -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.

@@ -162,6 +162,3 @@ func testUnsignedInt(t *testing.T) {
 func sliceOperands(array [2000]int) {
 	_ = array[C.KILO:C.KILO:C.KILO] // no type error
 }
-
-// set in cgo_thread_lock.go init
-var testThreadLockFunc = func(*testing.T) {}
--- a/misc/cgo/test/buildid_linux.go
+++ b/misc/cgo/test/buildid_linux.go
@@ -1,4 +1,4 @@
-// Copyright 2014 The Go Authors. All rights reserved.
+// Copyright 2014 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

@@ -22,7 +22,7 @@ func testBuildID(t *testing.T) {
 		if os.IsNotExist(err) {
 			t.Skip("no /proc/self/exe")
 		}
-		t.Fatal("opening /proc/self/exe: ", err)
+		t.Fatalf("opening /proc/self/exe: ", err)
 	}
 	defer f.Close()

--- a/misc/cgo/test/callback.go
+++ b/misc/cgo/test/callback.go
@@ -12,7 +12,6 @@ void callPanic(void);
 int callGoReturnVal(void);
 int returnAfterGrow(void);
 int returnAfterGrowFromGo(void);
-void callGoWithString(void);
 */
 import "C"

@@ -20,47 +19,20 @@ import (
 	"path"
 	"runtime"
 	"strings"
-	"sync"
 	"testing"
 	"unsafe"
 )

-// Pass a func value from nestedCall to goCallback using an integer token.
-var callbackMutex sync.Mutex
-var callbackToken int
-var callbackFuncs = make(map[int]func())
-
 // nestedCall calls into C, back into Go, and finally to f.
 func nestedCall(f func()) {
+	// NOTE: Depends on representation of f.
 	// callback(x) calls goCallback(x)
-	callbackMutex.Lock()
-	callbackToken++
-	i := callbackToken
-	callbackFuncs[i] = f
-	callbackMutex.Unlock()
-
-	// Pass the address of i because the C function was written to
-	// take a pointer.  We could pass an int if we felt like
-	// rewriting the C code.
-	C.callback(unsafe.Pointer(&i))
-
-	callbackMutex.Lock()
-	delete(callbackFuncs, i)
-	callbackMutex.Unlock()
+	C.callback(*(*unsafe.Pointer)(unsafe.Pointer(&f)))
 }

 //export goCallback
 func goCallback(p unsafe.Pointer) {
-	i := *(*int)(p)
-
-	callbackMutex.Lock()
-	f := callbackFuncs[i]
-	callbackMutex.Unlock()
-
-	if f == nil {
-		panic("missing callback function")
-	}
-	f()
+	(*(*func())(unsafe.Pointer(&p)))()
 }

 func testCallback(t *testing.T) {
@@ -179,6 +151,7 @@ func testCallbackCallers(t *testing.T) {
 	pc := make([]uintptr, 100)
 	n := 0
 	name := []string{
+		"test.goCallback",
 		"runtime.call16",
 		"runtime.cgocallbackg1",
 		"runtime.cgocallbackg",
@@ -186,7 +159,6 @@ func testCallbackCallers(t *testing.T) {
 		"runtime.asmcgocall",
 		"runtime.cgocall",
 		"test._Cfunc_callback",
-		"test.nestedCall.func1",
 		"test.nestedCall",
 		"test.testCallbackCallers",
 		"test.TestCallbackCallers",
@@ -194,10 +166,10 @@ func testCallbackCallers(t *testing.T) {
 		"runtime.goexit",
 	}
 	if unsafe.Sizeof((*byte)(nil)) == 8 {
-		name[0] = "runtime.call32"
+		name[1] = "runtime.call32"
 	}
 	nestedCall(func() {
-		n = runtime.Callers(4, pc)
+		n = runtime.Callers(2, pc)
 	})
 	if n != len(name) {
 		t.Errorf("expected %d frames, got %d", len(name), n)
@@ -205,7 +177,7 @@ func testCallbackCallers(t *testing.T) {
 	for i := 0; i < n; i++ {
 		f := runtime.FuncForPC(pc[i])
 		if f == nil {
-			t.Fatalf("expected non-nil Func for pc %d", pc[i])
+			t.Fatalf("expected non-nil Func for pc %p", pc[i])
 		}
 		fname := f.Name()
 		// Remove the prepended pathname from automatically
@@ -278,22 +250,6 @@ func goReturnVal() (r C.int) {
 	return
 }

-// Test that C can pass in a Go string from a string constant.
-func testCallGoWithString(t *testing.T) {
-	C.callGoWithString()
-	want := "string passed from C to Go"
-	if stringFromGo != want {
-		t.Errorf("string passed through C is %s, want %s", stringFromGo, want)
-	}
-}
-
-var stringFromGo string
-
-//export goWithString
-func goWithString(s string) {
-	stringFromGo = s
-}
-
 func testCallbackStack(t *testing.T) {
 	// Make cgo call and callback with different amount of stack stack available.
 	// We do not do any explicit checks, just ensure that it does not crash.
--- a/misc/cgo/test/callback_c.c
+++ b/misc/cgo/test/callback_c.c
@@ -1,8 +1,7 @@
-// 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.

-#include <string.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include "_cgo_export.h"
@@ -36,7 +35,7 @@ IntoC(void)
 long long
 mysleep(int seconds) {
 	long long st = GetTickCount();
-	Sleep(1000 * seconds);
+	sleep(seconds);
 	return st;
 }
 #else
@@ -81,10 +80,3 @@ returnAfterGrowFromGo(void)
 	return goReturnVal();
 }

-void
-callGoWithString(void)
-{
-	extern void goWithString(GoString);
-	const char *str = "string passed from C to Go";
-	goWithString((GoString){str, strlen(str)});
-}
--- a/misc/cgo/test/callback_c_gc.c
+++ b/misc/cgo/test/callback_c_gc.c
@@ -1,4 +1,4 @@
-// Copyright 2013 The Go Authors. All rights reserved.
+// Copyright 2013 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/misc/cgo/test/callback_c_gccgo.c
+++ b/misc/cgo/test/callback_c_gccgo.c
@@ -1,4 +1,4 @@
-// Copyright 2013 The Go Authors. All rights reserved.
+// Copyright 2013 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/misc/cgo/test/cflags.go
+++ b/misc/cgo/test/cflags.go
@@ -1,4 +1,4 @@
-// Copyright 2013 The Go Authors. All rights reserved.
+// Copyright 2013 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/misc/cgo/test/cgo_linux_test.go
+++ b/misc/cgo/test/cgo_linux_test.go
@@ -1,4 +1,4 @@
-// Copyright 2012 The Go Authors. All rights reserved.
+// 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.

@@ -6,7 +6,8 @@ package cgotest

 import "testing"

-func TestSetgid(t *testing.T)  { testSetgid(t) }
-func Test6997(t *testing.T)    { test6997(t) }
-func TestBuildID(t *testing.T) { testBuildID(t) }
-func Test9400(t *testing.T)    { test9400(t) }
+func TestSetgid(t *testing.T)      { testSetgid(t) }
+func Test6997(t *testing.T)        { test6997(t) }
+func TestBuildID(t *testing.T)     { testBuildID(t) }
+func Test9400(t *testing.T)        { test9400(t) }
+func TestSigProcMask(t *testing.T) { testSigProcMask(t) }
--- a/misc/cgo/test/cgo_stubs_android_test.go
+++ b/misc/cgo/test/cgo_stubs_android_test.go
@@ -1,13 +0,0 @@
-// 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 cgotest
-
-import "testing"
-
-// Stubs for tests that fails to build on Android
-func test6997(t *testing.T)        {}
-func test3775(t *testing.T)        {}
-func test8694(t *testing.T)        {}
-func testSigaltstack(t *testing.T) {}
--- a/Show More
+++ b/Show More