# 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>
Andrei Vieru <euvieru@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>
Daniel Fleischman <danielfleischman@gmail.com>
Daniel Theophanes <kardianos@gmail.com>
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>
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>
Kei Son <hey.calmdown@gmail.com>
Ken Friedenbach <kenliz@cruzio.com>
Kevin Ballard <kevin@sb.org>
Kyle Consalus <consalus@gmail.com>
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>
Paolo Giarrusso <p.giarrusso@gmail.com>
Petar Maymounkov <petarm@gmail.com>
Peter Froehlich <peter.hans.froehlich@gmail.com>
Peter Williams <pwil3058@gmail.com>
Raif S. Naffah <go@naffah-raif.name>
Risto Jaakko Saarelma <rsaarelm@gmail.com>
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>
Vinu Rajashekhar <vinutheraj@gmail.com>
William Josephson <wjosephson@gmail.com>
Yongjian Xu <i3dmaster@gmail.com>
