Maxim Krasnyansky <maxk@qualcomm.com>
Marcel Holtmann <marcel@holtmann.org>
Stephen Crane <steve.crane@rococosoft.com>
Jean Tourrilhes <jt@hpl.hp.com>
Jan Beutel <j.beutel@ieee.org>
Ilguiz Latypov <ilatypov@superbt.com>
Thomas Moser <thomas.moser@tmoser.ch>
Nils Faerber <nils@kernelconcepts.de>
Martin Leopold <martin@leopold.dk>
Wolfgang Heidrich <wolfgang.heidrich@esk.fhg.de>
Fabrizio Gennari <fabrizio.gennari@philips.com>
Brad Midgley <bmidgley@xmission.com>
Henryk Ploetz <henryk@ploetzli.ch>
Philip Blundell <pb@nexus.co.uk>
Johan Hedberg <johan.hedberg@intel.com>
Claudio Takahasi <claudio.takahasi@indt.org.br>
Eduardo Rocha <eduardo.rocha@indt.org.br>
Denis Kenzior <denis.kenzior@trolltech.com>
Frederic Dalleau <frederic.dalleau@access-company.com>
Frederic Danis <frederic.danis@access-company.com>
Luiz Augusto von Dentz <luiz.dentz@gmail.com>
Fabien Chevalier <fabchevalier@free.fr>
Ohad Ben-Cohen <ohad@bencohen.org>
Daniel Gollub <dgollub@suse.de>
Tom Patzig <tpatzig@suse.de>
Kai Vehmanen <kai.vehmanen@nokia.com>
Vinicius Gomes <vinicius.gomes@openbossa.org>
Alok Barsode <alok.barsode@azingo.com>
Bastien Nocera <hadess@hadess.net>
Albert Huang <albert@csail.mit.edu>
Glenn Durfee <gdurfee@google.com>
David Woodhouse <david.woodhouse@intel.com>
Christian Hoene <hoene@uni-tuebingen.de>
Pekka Pessi <pekka.pessi@nokia.com>
Siarhei Siamashka <siarhei.siamashka@nokia.com>
Nick Pelly <npelly@google.com>
Lennart Poettering <lennart@poettering.net>
Gustavo Padovan <gustavo@padovan.org>
Marc-Andre Lureau <marc-andre.lureau@nokia.com>
Bea Lam <bea.lam@nokia.com>
Zygo Blaxell <zygo.blaxell@xandros.com>
Forrest Zhao <forrest.zhao@intel.com>
Scott Talbot <psyc@stalbot.com>
Ilya Rubtsov <lusyaru@gmail.com>
Mario Limonciello <mario_limonciello@dell.com>
Filippo Giunchedi <filippo@esaurito.net>
Jaikumar Ganesh <jaikumar@google.com>
Elvis Pfutzenreuter <epx@signove.com>
Santiago Carot-Nemesio <scarot@libresoft.es>
José Antonio Santos Cadenas <jcaden@libresoft.es>
Francisco Alecrim <francisco.alecrim@openbossa.org>
Daniel Orstadius <daniel.orstadius@gmail.com>
Anderson Briglia <anderson.briglia@openbossa.org>
Anderson Lizardo <anderson.lizardo@openbossa.org>
Bruna Moreira <bruna.moreira@openbossa.org>
Brian Gix <bgix@codeaurora.org>
Andre Guedes <andre.guedes@openbossa.org>
Sheldon Demario <sheldon.demario@openbossa.org>
Lucas De Marchi <lucas.demarchi@profusion.mobi>
Szymon Janc <szymon.janc@codecoup.pl>
Syam Sidhardhan <s.syam@samsung.com>
Paulo Alcantara <pcacjr@gmail.com>
Jefferson Delfes <jefferson.delfes@openbossa.org>
Andrzej Kaczmarek <andrzej.kaczmarek@codecoup.pl>
Eder Ruiz Maria <eder.ruiz@openbossa.org>
Mikel Astiz <mikel.astiz@bmw-carit.de>
Chan-yeol Park <chanyeol.park@samsung.com>
João Paulo Rechi Vita <jprvita@gmail.com>
Larry Junior <larry.junior@openbossa.org>
Raymond Liu <raymond.liu@intel.com>
Radoslaw Jablonski <ext-jablonski.radoslaw@nokia.com>
Rafal Michalski <michalski.raf@gmail.com>
Dmitriy Paliy <dmitriy.paliy@nokia.com>
Bartosz Szatkowski <bulislaw@linux.com>
Lukasz Pawlik <lucas.pawlik@gmail.com>
Slawomir Bochenski <lkslawek@gmail.com>
Wayne Lee <waynelee@qualcomm.com>
Ricky Yuen <ryuen@qualcomm.com>
Takashi Sasai <sasai@sm.sony.co.jp>
Andre Dieb Martins <andre.dieb@signove.com>
Cristian Rodríguez <crrodriguez@opensuse.org>
Alex Deymo <deymo@chromium.org>
Petri Gynther <pgynther@google.com>
Scott James Remnant <scott@netsplit.com>
Jakub Tyszkowski <jakub.tyszkowski@tieto.com>
Grzegorz Kołodziejczyk <grzegorz.kolodziejczyk@tieto.com>
Marcin Krąglak <marcin.kraglak@tieto.com>
Łukasz Rymanowski <lukasz.rymanowski@codecoup.pl>
Jerzy Kasenberg <jerzy.kasenberg@tieto.com>
Arman Uguray <armansito@chromium.org>
Artem Rakhov <arakhov@chromium.org>
Mike Ryan <mikeryan@lacklustre.net>
David Herrmann <dh.herrmann@gmail.com>
Jacob Siverskog <jacob@teenageengineering.com>
Sebastian Chłąd <sebastian.chlad@tieto.com>
Alex Gal <a.gal@miip.ca>
Loic Poulain <loic.poulain@intel.com>
Gowtham Anandha Babu <gowtham.ab@samsung.com>
Bharat Panda <bharat.panda@samsung.com>
Marie Janssen <jamuraa@chromium.org>
Jaganath Kanakkassery <jaganath.k@samsung.com>
Michał Narajowski <michal.narajowski@codecoup.pl>
