# 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>
Albert Strasheim <fullung@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>
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>
Ben Olive <sionide21@gmail.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 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>
Eric Clark <zerohp@gmail.com>
Evan Shaw <chickencha@gmail.com>
Fazlul Shahriar <fshahriar@gmail.com>
Firmansyah Adiputra <frm.adiputra@gmail.com>
Florian Uekermann <florian@uekermann-online.de> <f1@uekermann-online.de>
Giles Lean <giles.lean@pobox.com>
Google Inc.
Graham Miller <graham.miller@gmail.com>
Gustavo Niemeyer <gustavo@niemeyer.net>
Hector Chu <hectorchu@gmail.com>
Icarus Sparry <golang@icarus.freeuk.com>
Isaac Wagner <ibw@isaacwagner.me>
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>
Jim McGrath <jimmc2@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>
Kevin Ballard <kevin@sb.org>
Kyle Consalus <consalus@gmail.com>
Markus Duft <markus.duft@salomon.at>
Martin Neubauer <m.ne@gmx.net>
Mathieu Lonjaret <mathieu.lonjaret@gmail.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>
Paolo Giarrusso <p.giarrusso@gmail.com>
Petar Maymounkov <petarm@gmail.com>
Peter Froehlich <peter.hans.froehlich@gmail.com>
Peter Mundy <go.peter.90@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>
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 Weinberg <stephen@q5comm.com>
Sven Almgren <sven@tras.se>
Tarmigan Casebolt <tarmigan@gmail.com>
Timo Savola <timo.savola@gmail.com>
Tor Andersson <tor.andersson@gmail.com>
Vincent Ambo <tazjin@googlemail.com>
Vinu Rajashekhar <vinutheraj@gmail.com>
Wei Guangjing <vcc.163@gmail.com>
William Josephson <wjosephson@gmail.com>
Yongjian Xu <i3dmaster@gmail.com>
Yasuhiro Matsumoto <mattn.jp@gmail.com>
Yuusei Kuwana <kuwana@kumama.org>
Yuval Pavel Zholkover <paulzhol@gmail.com>
