This file contains the PGP keys of various developers.

Users: pgp < KEYS
       gpg --import KEYS
Developers: 
        pgp -kxa <your name> and append it to this file.
        (pgpk -ll <your name> && pgpk -xa <your name>) >> this file.
        (gpg --list-sigs <your name>
             && gpg --armor --export <your name>) >> this file.

pub  1024D/CC69CEED 2003-09-25 Thomas DeWeese <deweese@apache.org>
sig 3       CC69CEED 2003-09-25   Thomas DeWeese <deweese@apache.org>
sig 3       88C3A5A5 2003-11-18   [User id not found]
sig 3       CC78C893 2003-11-18   Rich Bowen <rbowen@rcbowen.com>
sig 3       EE65E321 2003-11-24   Martin Kraemer <martin@apache.org>
sig 2       A1D69759 2003-11-24   Michael Kellen <idsfa@visi.com>
sig         FD093C41 2003-11-23   James M. Turner <turner@blackbear.com>
sig 2       76D83CC6 2003-11-22   Manoj Kasichainula <manoj@apache.org>
sig 3       A54DA2DF 2003-11-18   Erin Mulder <meara@alumni.princeton.edu>
sig 3       F5FC4B42 2003-11-21   Theodore W. Leung <twl@sauria.com>
sig 2       4C9165B6 2003-11-18   Aaron Mulder <ammulder@alumni.princeton.edu>
sig 2       65FDCDEE 2003-11-20   James Howison <james@freelancepropaganda.com>
sig 3       D147B776 2003-11-28   Mitch Comstock <mcomstock@raidworks.com>
sig 3       EE56550E 2003-12-01   Cliff Schmidt <cliff@alum.mit.edu>
sig         152924AF 2003-11-22   Sander Temme <sander@temme.net>
sig         964F31D9 2003-11-22   [User id not found]
sig         46B262C6 2003-11-24   Thies C. Arntzen <thies@project-pint.org>
sig 3       CE19D5C6 2003-11-18   Jamie Wallingford (legobuff) <jamie@legobuff.com>
sig 2       F88341D9 2003-11-30   Lars Eilebrecht <lars@eilebrecht.org>
sig 3       ADBF9E1A 2003-12-05   [User id not found]
sig 3       142B509B 2003-11-26   Glenn L. Nielsen <glenn@apache.org>
sub  1024g/9C4D8C6A 2003-09-25
sig         CC69CEED 2003-09-25   Thomas DeWeese <deweese@apache.org>
sig 3        98B1CC53 2010-10-23  Benson Margulies <bimargulies@apache.org>
sub   4096R/C5E91334 2010-10-23
sig          98B1CC53 2010-10-23  Benson Margulies <bimargulies@apache.org>


-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.2.2 (Cygwin)
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=w3cC

-----END PGP PUBLIC KEY BLOCK-----

pub   1024D/2983AB4B 2004-11-04
uid                  Cameron McCormack <cam@mcc.id.au>
sig 3        2983AB4B 2007-01-30  Cameron McCormack <cam@mcc.id.au>
sig     P X  65D0FD58 2005-11-01  CA Cert Signing Authority (Root CA) <gpg@cacert.org>
sig          1880283C 2006-01-13  Anibal Monsalve Salazar <anibal@debian.org>
sig 3        2983AB4B 2004-11-04  Cameron McCormack <cam@mcc.id.au>
sig          5653C9C4 2007-02-02  Helen Faulkner <helen@thousand-ships.com>
sig        1 C2429EC4 2007-02-03  Tanat Tonguthaisri <Tanat@Tanat.Net>
sig          B6D8A3F9 2007-02-06  James Healy <jimmy@deefa.com>
sig          B6D8A3F9 2007-02-06  James Healy <jimmy@deefa.com>
sig 3        6E63F4AA 2007-02-08  Julien Goodwin (Studio442) <jgoodwin@studio442.com.au>
uid                  Cameron McCormack (ASF) <cam@apache.org>
sig 3        2983AB4B 2007-01-30  Cameron McCormack <cam@mcc.id.au>
sig          5653C9C4 2007-02-02  Helen Faulkner <helen@thousand-ships.com>
sig          C2429EC4 2007-02-03  Tanat Tonguthaisri <Tanat@Tanat.Net>
sig          B6D8A3F9 2007-02-06  James Healy <jimmy@deefa.com>
sig          B6D8A3F9 2007-02-06  James Healy <jimmy@deefa.com>
sig 3        6E63F4AA 2007-02-08  Julien Goodwin (Studio442) <jgoodwin@studio442.com.au>
sub   1024g/8DBA9492 2004-11-04
sig          2983AB4B 2004-11-04  Cameron McCormack <cam@mcc.id.au>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.4.6 (GNU/Linux)
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=YT6v
-----END PGP PUBLIC KEY BLOCK-----
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG/MacGPG2 v2.0.12 (Darwin)
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=b8+3
-----END PGP PUBLIC KEY BLOCK-----
pub   2048R/D56B5F17 2012-10-30 [expires: 2017-10-29]
uid                  Luis Bernardo <lbernardo@apache.org>
sig 3        D56B5F17 2012-10-30  Luis Bernardo <lbernardo@apache.org>
sub   2048R/A83AC321 2012-10-30 [expires: 2017-10-29]
sig          D56B5F17 2012-10-30  Luis Bernardo <lbernardo@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.4.12 (Darwin)

mQENBFCQVQIBCADLgf95foKzcNUQMOoQOz9xtX3V4lYVy797am5GwHD2TdWNCma4
QzwmcNSbxhOvs1tinYw/RTg7k05TPcinPDdRRrOAzS0NRh4G8rfFhs7j+/Eyz84R
0lsclF0IXMunbQQP/XQHcTm8huz2PDPrqzgRM65XC3mBasFjbUL6UnYk40AEq22M
ZTIAwIXjvO5G8w4Xgj8goN96wX57P00LYNJBDTyflUAvM8U5C7C2BposgBy1shsM
wHKiitmjrlUpFM2ImCoIiKCHfaxUfxgnn8/sERll8Nq9k82UOSNGLtIWIZskpVBc
LRC8pKpB/SqAppsCjw0whSivB81DiaFZkbOlABEBAAG0JEx1aXMgQmVybmFyZG8g
PGxiZXJuYXJkb0BhcGFjaGUub3JnPokBPgQTAQIAKAUCUJBVAgIbAwUJCWYBgAYL
CQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQggNpidVrXxfjAQgAgqyUd8dWzyp6
v0x+ae2JuevL2YyePbQONxcxnttGz6COYmTmcR7P4UBrbo2IIfd1MwgKYMlQjhjy
GdBYReroBh43p9x1q5/XqCNpEYrOPPw8kefs1DuMVN+/3VeyWGjHBOxGmG/lBmrb
uo+UlIsFHJyS1SCi3s8Wz4Xqh+2/TCpiWEnBjoxv/h01nGb3uH8uCD52wMwDdmap
ITT4vwbo5168iAcFNKJmMMZbMiSItPG4Xjnl09mkjsxGbzTKIaF5UYkCuKlbQyHY
hWaWq21Nf3/z+5R0Ck8sGqAvJtMncQgkeFFRCVIPQDve+80AJNvaE2bdo1mliPJU
Nr/6gKS+erkBDQRQkFUCAQgA1aUuCpYBJtnUgyW/spjxV1iff20XNlu+cko2rhu/
GgV91l0LE7x7lKvQrOi8ZJ24F8bPUGwUyQFr7IVQZfBrLt+coFc2BvousU+7hHCq
oAGoxQmJQnIySV//sOaYqLOhj/Bzi39K8wiuR6xSpWfv9dWf8i5UAXVzQNixzn1Z
lNrQlbko7zHF//iAiz/jhkdir8Sl5/Kc9VY5JuR9HPugnYTutmh1kX88ywjhB01K
gJhaeH2Fx2T1xWctC3/aw8voe8SK+BZJCwRkWTzcixxgsB4ypfm16uD8tHsPHJf5
33KPVDlMqm9bELo4ZiiqGgYbBllKmvkntcDN6bCvBFxh+wARAQABiQElBBgBAgAP
BQJQkFUCAhsMBQkJZgGAAAoJEIIDaYnVa18XwYEIALNzDt09MMDBJqM+GxrygYte
+E+C++hMW4i/txaTcSwyWyy8jaukPlPvPkrulEAQk4cvSMS4Ei88+9LmxPNWR+ZH
2R2SfmK6IeRW+EJ7XPrHDhl/2aYXtT+CxjMaT7Bccx8ttv08286U+AWveSOmUW7k
P61lZzW4xesosbmKp0s08cUkXhz9Zv/bIDnxTZgVGmNmwS4wiP1kFztXTt7bGUva
wwvdUvINMp/lF1ZVPM6KCncfyokQG/9G7bV122RCPKMcBOljNM+q6KZVA1Zx9dSt
c1NM5vOYQhGd4wRYE2+xqjAC1VJz0fdLUBkv2qqBYVyXAAXMUpDdgrJsutms5pY=
=C/Js
-----END PGP PUBLIC KEY BLOCK-----
pub   4096R/7CDB6DEA 2015-05-20
uid                  Simon Steiner (CODE SIGNING KEY) <ssteiner@apache.org>
sub   4096R/73382B77 2015-05-20

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1
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=n+z/
-----END PGP PUBLIC KEY BLOCK-----
