# This is the official list of Go authors for copyright purposes.
# This file is distinct from the CONTRIBUTORS files.
# See the latter for an explanation.

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

Abhinav Gupta <abhinav.g90@gmail.com>
Adrian O'Grady <elpollouk@gmail.com>
Alex Brainman <alex.brainman@gmail.com>
Amrut Joshi <amrut.joshi@gmail.com>
Andrew Skiba <skibaa@gmail.com>
Andrey Mirtchovski <mirtchovski@gmail.com>
Andy Davis <andy@bigandian.com>
Anh Hai Trinh <anh.hai.trinh@gmail.com>
Anthony Starks <ajstarks@gmail.com>
Aron Nopanen <aron.nopanen@gmail.com>
Arvindh Rajesh Tamilmani <art@a-30.net>
Ben Olive <sionide21@gmail.com>
Charles L. Dorian <cldorian@gmail.com>
Chris Lennert <calennert@gmail.com>
Christopher Wedgwood <cw@f00f.org>
Conrad Meyer <cemeyer@cs.washington.edu>
David G. Andersen <dave.andersen@gmail.com>
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>
Evan Shaw <chickencha@gmail.com>
Fazlul Shahriar <fshahriar@gmail.com>
Firmansyah Adiputra <frm.adiputra@gmail.com>
Giles Lean <giles.lean@pobox.com>
Google Inc.
Hector Chu <hectorchu@gmail.com>
Icarus Sparry <golang@icarus.freeuk.com>
Isaac Wagner <ibw@isaacwagner.me>
James Meneghello <rawrz0r@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>
Kei Son <hey.calmdown@gmail.com>
Ken Friedenbach <kenliz@cruzio.com>
Kevin Ballard <kevin@sb.org>
Micah Stetson <micah.stetson@gmail.com>
Michael Elkins <michael.elkins@gmail.com>
Michael Hoisie <hoisie@gmail.com>
Moriyoshi Koizumi <mozo@mozo.jp>
Môshe van der Sterre <moshevds@gmail.com>
Petar Maymounkov <petarm@gmail.com>
Peter Froehlich <peter.hans.froehlich@gmail.com>
Raif S. Naffah <go@naffah-raif.name>
Roger Peppe <rogpeppe@gmail.com>
Ross Light <rlight2@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 Weinberg <stephen@q5comm.com>
Sven Almgren <sven@tras.se>
Timo Savola <timo.savola@gmail.com>
Tor Andersson <tor.andersson@gmail.com>
William Josephson <wjosephson@gmail.com>
Yongjian Xu <i3dmaster@gmail.com>
