# This is the official list of people who can contribute
# (and typically have contributed) code to the Go repository.
# The AUTHORS file lists the copyright holders; this file
# lists people.  For example, Google employees are listed here
# but not in AUTHORS, because Google holds the copyright.
#
# The submission process automatically checks to make sure
# that people submitting code are listed in this file (by email address).
#
# Names should be added to this file only after verifying that
# the individual or the individual's organization has agreed to
# the appropriate Contributor License Agreement, found here:
#
#     http://code.google.com/legal/individual-cla-v1.0.html
#     http://code.google.com/legal/corporate-cla-v1.0.html
#
# The agreement for individuals can be filled out on the web.
#
# When adding J Random Contributor's name to this file,
# either J's name or J's organization's name should be
# added to the AUTHORS file, depending on whether the
# individual or corporate CLA was used.

# Names should be added to this file like so:
#     Name <email address>
#
# An entry with two email addresses specifies that the
# first address should be used in the submit logs and
# that the second address should be recognized as the
# same person when interacting with Rietveld.

# Please keep the list sorted.

Abhinav Gupta <abhinav.g90@gmail.com>
Adam Langley <agl@golang.org>
Adrian O'Grady <elpollouk@gmail.com>
Alex Brainman <alex.brainman@gmail.com>
Amrut Joshi <amrut.joshi@gmail.com>
Andrei Vieru <euvieru@gmail.com>
Andrew Gerrand <adg@golang.org>
Andrew Skiba <skibaa@gmail.com>
Andrey Mirtchovski <mirtchovski@gmail.com>
Andy Davis <andy@bigandian.com>
Anh Hai Trinh <anh.hai.trinh@gmail.com>
Anschel Schaffer-Cohen <anschelsc@gmail.com>
Anthony Martin <ality@pbrane.org>
Anthony Starks <ajstarks@gmail.com>
Aron Nopanen <aron.nopanen@gmail.com>
Arvindh Rajesh Tamilmani <art@a-30.net>
Austin Clements <aclements@csail.mit.edu>
Ben Eitzen <eitzenb@golang.org>
Ben Olive <sionide21@gmail.com>
Bill Neubauer <wcn@golang.org> <wcn@google.com>
Brad Fitzpatrick <brad@danga.com> <bradfitz@gmail.com>
Brendan O'Dea <bod@golang.org>
Cary Hull <chull@google.com>
Charles L. Dorian <cldorian@gmail.com>
Chris Lennert <calennert@gmail.com>
Christian Himpel <chressie@googlemail.com>
Christopher Wedgwood <cw@f00f.org>
Conrad Meyer <cemeyer@cs.washington.edu>
Corey Thomasson <cthom.lists@gmail.com>
Dan Sinclair <dan.sinclair@gmail.com>
Daniel Fleischman <danielfleischman@gmail.com>
Daniel Nadasi <dnadasi@google.com>
Daniel Theophanes <kardianos@gmail.com>
David G. Andersen <dave.andersen@gmail.com>
David Symonds <dsymonds@golang.org>
David Titarenco <david.titarenco@gmail.com>
Dean Prichard <dean.prichard@gmail.com>
Devon H. O'Dell <devon.odell@gmail.com>
Eden Li <eden.li@gmail.com>
Eric Clark <zerohp@gmail.com>
Evan Shaw <chickencha@gmail.com>
Fazlul Shahriar <fshahriar@gmail.com>
Firmansyah Adiputra <frm.adiputra@gmail.com>
Fumitoshi Ukai <ukai@google.com>
Giles Lean <giles.lean@pobox.com>
Gustavo Niemeyer <gustavo@niemeyer.net> <n13m3y3r@gmail.com>
Hector Chu <hectorchu@gmail.com>
Ian Lance Taylor <iant@golang.org>
Icarus Sparry <golang@icarus.freeuk.com>
Isaac Wagner <ibw@isaacwagner.me>
Ivan Krasin <krasin@golang.org>
Jacob Baskin <jbaskin@google.com>
James Aguilar <jaguilar@google.com>
James Fysh <james.fysh@gmail.com>
James Meneghello <rawrz0r@gmail.com>
James Toy <nil@opensesame.st>
James Whitehead <jnwhiteh@gmail.com>
Jan H. Hosang <jan.hosang@gmail.com>
Jan Mercl <befelemepeseveze@gmail.com>
Joe Poirier <jdpoirier@gmail.com>
Jonathan Wills <runningwild@gmail.com>
Josh Goebel <dreamer3@gmail.com>
Jukka-Pekka Kekkonen <karatepekka@gmail.com>
Kai Backman <kaib@golang.org>
Kei Son <hey.calmdown@gmail.com>
Ken Friedenbach <kenliz@cruzio.com>
Ken Thompson <ken@golang.org>
Kevin Ballard <kevin@sb.org>
Kirklin McDonald <kirklin.mcdonald@gmail.com>
Kyle Consalus <consalus@gmail.com>
Larry Hosken <lahosken@golang.org>
Luuk van Dijk <lvd@golang.org> <lvd@google.com>
Mark Zavislak <zavislak@google.com>
Markus Duft <markus.duft@salomon.at>
Martin Neubauer <m.ne@gmx.net>
Mathieu Lonjaret <mathieu.lonjaret@gmail.com>
Maxim Ushakov <ushakov@google.com>
Micah Stetson <micah.stetson@gmail.com>
Michael Elkins <michael.elkins@gmail.com>
Michael Hoisie <hoisie@gmail.com>
Mikio Hara <mikioh.mikioh@gmail.com>
Mikkel Krautz <mikkel@krautz.dk> <krautz@gmail.com>
Moriyoshi Koizumi <mozo@mozo.jp>
Môshe van der Sterre <moshevds@gmail.com>
Nicholas Waples <nwaples@gmail.com>
Nigel Tao <nigeltao@golang.org>
Paolo Giarrusso <p.giarrusso@gmail.com>
Petar Maymounkov <petarm@gmail.com>
Peter Froehlich <peter.hans.froehlich@gmail.com>
Peter McKenzie <petermck@google.com>
Peter Mundy <go.peter.90@gmail.com>
Péter Szabó <pts@google.com>
Peter Williams <pwil3058@gmail.com>
Phil Pennock <pdp@golang.org>
Raif S. Naffah <go@naffah-raif.name>
Risto Jaakko Saarelma <rsaarelm@gmail.com>
Rob Pike <r@golang.org>
Robert Griesemer <gri@golang.org>
Roger Peppe <rogpeppe@gmail.com>
Ross Light <rlight2@gmail.com>
Russ Cox <rsc@golang.org>
Sam Thorogood <thorogood@google.com>
Scott Schwartz <scotts@golang.org>
Scott Lawrence <bytbox@gmail.com>
Sebastien Binet	<seb.binet@gmail.com>
Sergei Skorobogatov <skorobo@rambler.ru>
Sergey 'SnakE' Gromov <snake.scaly@gmail.com>
Sergio Luis O. B. Correia <sergio@larces.uece.br>
Spring Mc <heresy.mc@gmail.com>
Stephen Ma <stephenm@golang.org>
Stephen Weinberg <stephen@q5comm.com>
Sven Almgren <sven@tras.se>
Tarmigan Casebolt <tarmigan@gmail.com>
Tom Szymanski <tgs@google.com>
Timo Savola <timo.savola@gmail.com>
Tor Andersson <tor.andersson@gmail.com>
Trevor Strohman <trevor.strohman@gmail.com>
Vincent Ambo <tazjin@googlemail.com>
Vinu Rajashekhar <vinutheraj@gmail.com>
Vish Subramanian <vish@google.com>
Wei Guangjing <vcc.163@gmail.com>
William Josephson <wjosephson@gmail.com>
Yongjian Xu <i3dmaster@gmail.com>
Yuusei Kuwana <kuwana@kumama.org>
Yves Junqueira <yves.junqueira@gmail.com>
