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@codecoup.pl>
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>
