List of the authors of code contained in BusyBox.

If you have code in BusyBox, you should be listed here.  If you should be
listed, or the description of what you have done needs more detail, or is
incorect, _please_ let me know.

 -Erik

-----------

Emanuele Aina <emanuele.aina@tiscali.it>
	run-parts

Erik Andersen <andersen@codepoet.org>, <andersee@debian.org>
    Tons of new stuff, major rewrite of most of the
    core apps, tons of new apps as noted in header files.

Laurence Anderson <l.d.anderson@warwick.ac.uk>
    rpm2cpio, unzip, get_header_cpio, read_gz interface

Edward Betts <edward@debian.org>
    expr, hostid, logname, tty, wc, whoami, yes
 
John Beppu <beppu@lineo.com>
    du, head, nslookup, sort, tee, uniq

Brian Candler <B.Candler@pobox.com>
    tiny-ls(ls)

Randolph Chung <tausq@debian.org>
    fbset, ping, hostname, and mkfifo

Dave Cinege <dcinege@psychosis.com>	
    more(v2), makedevs, dutmp, modularization, auto links file, 
    various fixes, Linux Router Project maintenance

Jordan Crouse <jordan@cosmicpenguin.net>
	ipcalc

Magnus Damm <damm@opensource.se>
    tftp client
    insmod powerpc support

Larry Doolittle <ldoolitt@recycle.lbl.gov>
    pristine source directory compilation, lots of patches and fixes.

Gennady Feldman <gfeldman@cachier.com>
    Sysklogd (single threaded syslogd, IPC Circular buffer support,
    logread), various fixes.

Karl M. Hegbloom <karlheg@debian.org>
    cp_mv.c, the test suite, various fixes to utility.c, &c.

Daniel Jacobowitz <dan@debian.org>
    mktemp.c

Matt Kraai <kraai@alumni.cmu.edu>
    documentation, bugfixes, test suite

Stephan Linz <linz@li-pro.net>
	ipcalc, Red Hat equivalence

John Lombardo <john@deltanet.com>	
    dirname, tr

Glenn McGrath <bug1@optushome.com.au>
    ar, dpkg, dpkg-deb

Vladimir Oleynik <dzo@simtreas.ru>
    cmdedit; xargs(current);
    ports: ash, crond, fdisk, stty, traceroute, telnetd, top;
    locale, various fixes
    and irreconcilable critic of everything not perfect.

Bruce Perens <bruce@pixar.com>
    Original author of BusyBox. His code is still in many apps.

Tim Riker <Tim@Rikers.org>
    bug fixes, member of fan club

Kent Robotti <robotti@metconnect.com>
    reset, tons and tons of bug reports and patchs.

Chip Rosenthal <chip@unicom.com>, <crosenth@covad.com>
    wget - Contributed by permission of Covad Communications

Pavel Roskin <proski@gnu.org>
    Lots of bugs fixes and patches.

Gyepi Sam <gyepi@praxis-sw.com>
    Remote logging feature for syslogd

Linus Torvalds <torvalds@transmeta.com>
    mkswap, fsck.minix, mkfs.minix

Mark Whitley <markw@lineo.com> <markw@codepoet.org>
    grep, sed, cut, xargs(previous),
    style-guide, new-applet-HOWTO, bug fixes, etc.

Charles P. Wright <cpwright@villagenet.com>
    gzip, mini-netcat(nc)

Enrique Zanardi <ezanardi@ull.es>
    tarcat (since removed), loadkmap, various fixes, Debian maintenance
