# Names should be added to this file with this pattern:
#
# For individuals:
#   Name <email address>
#
# For organizations:
#   Organization <fnmatch pattern>
#
# See python fnmatch module documentation for more information.

Google Inc. <*@google.com>
IBM Inc. <*@*.ibm.com>
Loongson Technology Corporation Limited. <*@loongson.cn>
MIPS Technologies, Inc. <*@mips.com>
Opera Software ASA <*@opera.com>
The Chromium Authors <*@chromium.org>
Vewd Software AS <*@vewd.com>
Vivaldi Technologies AS <*@vivaldi.com>
Yandex LLC <*@yandex-team.ru>

Alexis Menard <alexis.menard@intel.com>
Andrew Boyarshin <andrew.boyarshin@gmail.com>
Anuj Kumar Sharma <anujk.sharma@samsung.com>
DanCraft99 <simputest@gmail.com>
Gergely Nagy <ngg@ngg.hu>
Ilia K <ki.stfu@gmail.com>
Ivan Naydonov <samogot@gmail.com>
Joe Armstrong <joearmstrong334@gmail.com>
Julien Brianceau <jbriance@cisco.com>
Kal Conley <kcconley@gmail.com>
Kamil Rytarowski <krytarowski@gmail.com>
Martijn Croonen <martijn@martijnc.be>
Matej Knopp <matej.knopp@gmail.com>
Michael Gilbert <floppymaster@gmail.com>
Milko Leporis <milko.leporis@imgtec.com>
Mohan Reddy <mohan.reddy@samsung.com>
Raphael Kubo da Costa <raphael.kubo.da.costa@intel.com>
Riku Voipio <riku.voipio@linaro.org>
Saikrishna Arcot <saiarcot895@gmail.com>
Tim Niederhausen <tim@rnc-ag.de>
Tomas Popela <tomas.popela@gmail.com>
Tripta Gupta <tripta.g@samsung.com>
Yuriy Taraday <yorik.sar@gmail.com>
