# This is the official list of glog 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.

Abhishek Dasgupta <abhi2743@gmail.com>
Abhishek Parmar <abhishek@orng.net>
Andy Ying <andy@trailofbits.com>
Brian Silverman <bsilver16384@gmail.com>
Google Inc.
Guillaume Dumont <dumont.guillaume@gmail.com>
Michael Tanner <michael@tannertaxpro.com>
romange <romange@users.noreply.github.com>
Sergiu Dotenco <sergiu.dotenco@th-nuernberg.de>
tbennun <tbennun@gmail.com>
Teddy Reed <teddy@prosauce.org>
