A Costa <agcosta@gis.net>
Aaron M. Ucko <ucko@debian.org>
Adam Heath <doogie@debian.org>
Adeodato Simó <adeodato@debian.org>
Alberto Garcia <berto@gpul.org>
Anand Kumria <wildfire@progsoc.org>
Andreas Barth <aba@not.so.argh.org>
Andreas Metzler <ametzler@debian.org>
Andreas Påhlsson <andreas.pahlsson@xcerion.com>
Andrew Ferrier <andrew@new-destiny.co.uk>
Andrew Hobson <ahobson@eng.mindspring.net>
Andrew Suffield <asuffield@debian.org>
Anthony Towns <aj@azure.humbug.org.au>
Aurelien Jarno <aurel32@debian.org>
Bart Cornelis <cobaco@skolelinux.no>
Bart Martens <bart.martens@advalvas.be>
Bastian Kleineidam <calvin@debian.org>
Ben Collins <bcollins@debian.org>
Ben Pfaff <blp@cs.stanford.edu>
Bill Allombert <ballombe@debian.org>
Branden Robinson <branden@debian.org>
Branko Lankester
Brian M. Carlson <sandals@crustytoothpaste.ath.cx>
Bruce Perens <bruce@pixar.com>
Bruce Sass <bmsass@shaw.ca>
Carl Streeter <streeter@cae.wisc.edu>
Carlos Laviola <claviola@brfree.com.br>
Carlos Z.F. Liu <carlosliu@users.sourceforge.net>
Changwoo Ryu <cwryu@debian.org>
Charles Briscoe-Smith <cpbs@debian.org>
Christian Haggstrom <chm@c00.info>
Christoph Maser <cm@financial.com>
Christophe Le Bars <clebars@teaser.fr>
Claus Hindsgaul <claus.hindsgaul@gmail.com>
Clytie Siddall <clytie@riverland.net.au>
Colin Plumb <colin@nyx.net>
Colin Watson <cjwatson@debian.org>
Dafydd Harries <daf@muse.19inch.net>
Dan Gohman <gohmandj@mrs.umn.edu>
Daniel Hahler <debian-bugs@thequod.de>
Daniel Jacobowitz <dan@debian.org>
Daniel Leidert <daniel.leidert@wgdd.de>
Daniel Nylander <yeager@lidkoping.net>
Darren Stalder <torin@daft.com>
David Huggins-Daines <dhd@debian.org>
David Lopez Moreno <david.lopez.moreno@hispalinux.es>
Denis Barbier <barbier@debian.org>
Don Armstrong <don@debian.org>
Eddy Petrișor <eddy.petrisor@gmail.com>
Erast Benson <erast@gnusolaris.org>
Erick Branderhorst <branderhorst@heel.fgg.eur.nl>
Flavio Stanchina <flavio@stanchina.net>
Frank S. Thomas <frank@thomas-alfeld.de>
Frédéric Bothamy <frederic.bothamy@free.fr>
Galen Hazelwood <galenh@debian.org>
Goswin Brederlow <brederlo@informatik.uni-tuebingen.de>
Guy Maor <maor@debian.org>
Hans Fredrik Nordhaug <hans@nordhaug.priv.no>
Hartmut Koptein <koptein@naffel.de>
Heiko Schlittermann <heiko@lotte.sax.de>
Helge Kreutzmann <debian@helgefjell.de>
Hiroshi KISE <fuyuneko@ryukyu.ne.jp>
Holger Wansing <linux@wansing-online.de>
Ian Eure <ieure@debian.org>
Ian Jackson <ian@chiark.greenend.org.uk>
Ian Murdock <imurdock@debian.org>
Ian Zimmerman <itz@buug.org>
Ingo Saitz <ingo@debian.org>
Ivar Smolin <okul@linux.ee>
Ivo Timmermans <itimmermans@bigfoot.com>
J.H.M. Dassen <jdassen@cistron.nl>
Jacobo Tarrio <jtarrio@debian.org>
James R. Van Zandt <jrvz@comcast.net>
James Troup <troup@debian.org>
James Vega <jamessan@debian.org>
Jared Spiegel <jrrs@frontiernet.net>
Jari Aalto <jari.aalto@cante.net>
Javier Fernández-Sanguino Peña <jfs@debian.org>
Jeffrey W. Baker <jwbaker@acm.org>
Jeroen van Wolffelaar <jeroen@wolffelaar.nl>
Jim Pick <jim@jimpick.com>
Jim Van Zandt <jrv@vanzandt.mv.com>
Jiří Paleček <jpalecek@web.de>
Joachim Breitner <mail@joachim-breitner.de>
Joel Klecker <jk@espy.org>
Joey Hess <joeyh@debian.org>
Johannes Veser <veser@gmx.de>
John Wright <jsw@debian.org>
John Zaitseff <J.Zaitseff@zap.org.au>
Jonathan Nieder <jrnieder@gmail.com>
Jordi Mallach <jordi@debian.org>
Josip Rodin <jrodin@jagor.srce.hr>
Juan Cespedes <cespedes@debian.org>
Juergen Menden <menden@morgana.camelot.de>
Juho Vuori <javuori@cc.helsinki.fi>
Julian Gilbey <jdg@debian.org>
Julien Cristau <jcristau@debian.org>
Junichi Uekawa <dancer@debian.org>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Ken Bloom <kbloom@gmail.com>
Kenshi Muto <kmuto@debian.org>
Kevin Ryde <user42@zip.com.au>
Kim-Minh Kaplan <kkaplan@cdfhp3.in2p3.fr>
Klee Dienes <klee@debian.org>
Koblinger Egmont <egmont@uhulinux.hu>
Kurt B. Kaiser <kbk@shore.net>
Kylan Robinson <Kylan_Robinson@selinc.com>
Lele Gaifax <lele@seldati.it>
Lennert Buytenhek <buytenh+debian@wantstofly.org>
Ludovic Rousseau <rousseau@debian.org>
Manoj Srivastava <srivasta@debian.org>
Marc Dequènes <duck@duckcorp.org>
Marc Haber <mh+debian-packages@zugschlus.de>
Marcel Toele <mtoele@kern.nl>
Marco d'Itri <md@linux.it>
Marcus Brinkmann <brinkmd@debian.org> 
Mark Rosenstand <mark@borkware.net>
Martin Koeppe <mkoeppe@gmx.de>
Masato Taruishi <taru@debian.or.jp>
Mathias Weidner <mathias@weidner.in-bad-schmiedeberg.de>
Matt Kraai <kraai@ftbfs.org>
Matt Welsh <mdw@sunsite.unc.edu>
Matt Zimmerman <mdz@debian.org>
Maximilian Attems <debian@sternwelten.at>
Michael Alan Dorman <mdorman@calder.med.miami.edu>
Michael Shields <shields@crosslink.net>
Michael Sobolev <mss@transas.com>
Michael Vogt <mvo@ubuntu.com>
Michel Lespinasse <walken@zoy.org>
Miguel Figueiredo <elmig@debianpt.org>
Miquel van Smoorenburg <miquels@cistron.nl>
Miroslav Kure <kurem@debian.cz>
Modestas Vainius <modax@debian.org>
Moritz Muehlenhoff <jmm@inutil.org>
NIIBE Yutaka <gniibe@fsij.org>
Nicolas Bonifas
Nicolas François <nicolas.francois@centraliens.net>
Nicolás Lichtmaier <nick@debian.org>
Nils Rennebarth <nils@debian.org>
Peter Krefting <peterk@debian.org>
Peter Mann <Peter.Mann@tuke.sk>
Peter van Dijk <peter@dataloss.nl>
Petr Cech <cech@atrey.karlin.mff.cuni.cz>
Philippe Batailler <pbatailler@teaser.fr>
Pierre Habouzit <madcoder@debian.org>
Piotr Engelking <inkerman42@gmail.com>
Piotr Roszatycki <dexter@fnet.pl>
Rakesh 'arky' Ambati <rakesh_ambati@yahoo.com>
Raphaël Hertzog <hertzog@debian.org>
Richard Kettlewell <rjk@sfere.greenend.org.uk>
Riku Voipio <riku.voipio@iki.fi>
Robert Luberda <robert@debian.org>
Robert Millan <rmh@debian.org>
Roderick Schertler <roderick@argon.org>
Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
Russell Coker <russell@coker.com.au>
SZERVÁC Attila <sas@321.hu>
Samuel Thibault <samuel.thibault@ens-lyon.org>
Scott Barker <scott@mostlylinux.ab.ca>
Scott James Remnant <scott@netsplit.com>
Sean Finney <seanius@seanius.net>
Sergio Gelato <Sergio.Gelato@astro.su.se>
Stefano Canepa <sc@linux.it>
Stepan Golosunov <stepan@golosunov.pp.ru>
Stephane Bortzmeyer <stephane@sources.org>
Steve Langasek <vorlon@debian.org>
Sven Joachim <svenjoac@gmx.de>
Sven Rudolph <sr1@loom.sax.de>
Thomas Morin <thomas.morin@enst-bretagne.fr>
Timothy G Abbott <tabbott@MIT.EDU>
Tom Lees <tom@lpsg.demon.co.uk>
Tomas Pospisek <tpo_deb@sourcepole.ch>
Topi Miettinen <Topi.Miettinen@nic.fi>
Vasilis Vasaitis <v.vasaitis@sms.ed.ac.uk>
Wayne Davison <wayned@users.sourceforge.net>
Wichert Akkerman <wakkerma@debian.org>
Yuri Kozlov <kozlov.y@gmail.com>
Zefram <zefram@fysh.org>
