This file contains the GPG keys of Apache Samza developers.

Users:    gpg --import KEYS

Developers:
  Create a key:
    gpg --gen-key

  Adding your key to this file:
    (gpg --list-sigs <key id> && gpg --armor --export <key id>) >> this file.

  Publish the key:
    gpg --keyserver pgp.mit.edu --send-keys <key id>

  Signing another developers key:
    gpg --keyserver pgp.mit.edu --search-keys <name or email>
    gpg --keyserver pgp.mit.edu --recv-keys <key id>
    gpg --sign-key <key id>
    gpg --keyserver pgp.mit.edu --send-keys <key id>

  Additional Information:
    http://www.apache.org/dev/openpgp.html#generate-key

********************************* PLEASE NOTE **********************************

  Releases will be signed using one of these keys in this file. This file will
  be available with the distributed Apache Samza releases at:

      https://dist.apache.org/repos/dist/samza/KEYS

********************************************************************************


pub   4096R/F96DF3CE 2014-06-09 [expires: 2018-06-09]
uid                  Jakob Homan (Release signing key) <jghoman@apache.org>
sig 3        F96DF3CE 2014-06-09  Jakob Homan (Release signing key) <jghoman@apache.org>
sub   4096R/DE2BB10A 2014-06-09 [expires: 2018-06-09]
sig          F96DF3CE 2014-06-09  Jakob Homan (Release signing key) <jghoman@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG/MacGPG2 v2.0.22 (Darwin)
Comment: GPGTools - https://gpgtools.org
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=+3op
-----END PGP PUBLIC KEY BLOCK-----
pub   4096R/352D8EDF 2014-04-13 [expires: 2019-04-12]
uid                  Martin Kleppmann <martin@kleppmann.com>
sig 3        352D8EDF 2014-04-13  Martin Kleppmann <martin@kleppmann.com>
sig          CF9B85D5 2014-04-13  [User ID not found]
sub   4096R/92347F1A 2014-04-13 [expires: 2019-04-12]
sig          352D8EDF 2014-04-13  Martin Kleppmann <martin@kleppmann.com>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG/MacGPG2 v2.0.22 (Darwin)
Comment: GPGTools - https://gpgtools.org

mQINBFNJ1z8BEACcauB3ESZCEWstFylKsVspq56FfA35mVWZhxSb9yyKUGispBwx
RTQuZ8uybpaEh7mEPDqPVDkw1zPxUXA5avSPaJvWNWUAX07AMbYhNyRcfjOzHAgN
TbH7MoaPpnc5I2b+4r9kuZ3dXCqe81VVJNUSpuzRJM2KJbwyPQ9gVOM0PEcZsolZ
dV1XQhKFjB+uCiNSPN/XsRekqwDw7zanN/1g44SaKNpZwGnl8owOd30Hm3xl4g1V
9y51O8Nk/iFWwWZMwBih07EMMTfMERv0X2jPCq/d7CgdXisoyW0f5ZAxnFm69Erw
oIrn/FOXe38OX3WWWYGEZNggUy06zIeTQT2ow67TuZJZ++KFDeeD6VKSvTcFnVZE
qAEJVe0UcCLKd2/AFg/CWApHtTBFSDh8krbmsvg4F9YY/ejDxtvm2vVZi/pY4MB8
audTw8JkWnJeLpGoVydczme6miva/MeRqC7mIL/JFfxHFK+gMkQfj48dU21csvt1
z0lZPFhHvIvg4LfdUWwCYHYk2NZrQo+5JzVultL2i9YU5Cdmy3sxoeUQ4vBpHiy1
i+AKvbM3DMwTZtbYi2nKtE/LpicZbcEnCQfVPoX3fXd7pp/bDR74OWUTBUDuXKXf
rqGPTU6GnlnDiwAFgZILkocppSplEdCPTBq7zXc3c4i+IbahgI1XMlANpwARAQAB
tCdNYXJ0aW4gS2xlcHBtYW5uIDxtYXJ0aW5Aa2xlcHBtYW5uLmNvbT6JAj4EEwEC
ACgFAlNJ1z8CGwMFCQlmAYAGCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJEO14
+PU1LY7fuiYQAIB5RI+bai0/QPQ1o4Kqe7sqPiGy7M7PWPYtIRK962qaOGG0KIAr
X1+jqJ9K7tNyA0RJU6Ab37MhTDMblyQ+JCBpE6H6f74dxMZhiEfatLgpBASYqIw0
cAhQcpMQgAJ2OVHTNi7BGoiR7s8yYyf+xBWfssywjFbpr+3tiCsiOzDHlFHulXDd
04yvYXYds9y1m90ncnFtil41PZxteyiaPW/8RPrrleNfkG23IVClUUd8mUMO0QIh
B1pewKmlEnzqVFBoxwQgreOnVZkDRQsasX8VNDZ3PQKCNkWPX/xNZ/1hgPvbPuwo
nZ0kIQkHcT9968nb+Ofv6NYbcVMs5gXN3yxKDZ5q6Lh7TACOZHjYSM+jCCbFAlhq
M/ThhCS4q8GUm2UEZUtyo/i9huKbRqVWh+5SAF4V2qtHxq2nRAs54bcaUdYx6Bln
omC0/SkvcsoEMIanAmu4XScAqbXah7n89c67tC/U7qUF52pAuQzP1rYcI2ihCR6n
pmmJkWb4fKLny2LJhO0imF9gMxeGxzOxFNPN9bf/7i1RUe16Lcn2FN60QzB8GofB
dRlFpNogHdq9ZgpVarOw/pobHMUGGHmmsreHYDR03f05hW1e8csdYVpBM3Rt0dwu
9MV+YDRV2Hg40ahRd3LVX9WfJdHPEEWg7Uktsko0nnSqmtYtLB1jGr1xiJwEEAEC
AAYFAlNJ13YACgkQvRldnc+bhdWuvQQAxK5vN/Bi9/pbjor2/KRgrM5i/HdkBSaR
zazxK0Pc2xaxc0WK8nCP7k8CtmPRcZqXnYocsndGBw5lCdklLDZzqgjnwL1/GjSF
KQkYFLzzdX77IdhWmUINikzhYBXh6jxaLviipgl/nY8aP8+p4uuPZuMuZjT8x7jP
92JgiyNA/re5Ag0EU0nXPwEQAL6rWMngI1KnfbyFlJalt8M8LPZpl/eKfIOYLTiz
YVG/FejFMRiJQiPjzKz17OmgfHN0nbAov+Z1Yfoqf+d1h4i/wriBO7uLcUrKtNU8
sL21TJM5FjqSEdZDzls+3yHyeQDsE7zYVgWdB7htPgScwmAW82Wy4tJ+9Q+Vh7BK
VLAHbujkWTpJZIvfK+oC5L1C8KBIs8Aiadk5MNZWUFj4fUgmfM0MPY1DEw3a7V7p
+IWxAZSYSbI9rdiumHxvs4hJguNVuX4BfkO9dJApwvIQdAXDyo9YCSvY3eG/rJ4w
fEuCnqi81Z23anj5jWvY6Bnmd4ryrwERfaGbcr6JFKZcRxUq4iFMaDQsvvBhZzjT
cFWCO+jPsxYkg3yguUydRv6gjMBFnJ+jHM5U4EKU246pH+zgYQLbq4hnwAWC19y8
afh8EdZ5EJqli2/7vQhR1vTQO7vqD0CRESyAMW0OBRxPmMfMnOSU5W3ejx51GKLS
3mrOTyW0dr2KR59Drb3Oq1SPlV30KP4xw2znQtgD7oR/AEJxaTQAFJaco7MSoAvM
E9STKg/xCcF8HwuNanzU0sbeJoLLvTvW6HyvKv0uz11send86OxNqVNmPDOkjZP5
cR+QU3Ing41vOQO7WW7VaoU/YD8yX8B4sQu/sUSQDMn3ZYjZHBeY4LMd4szx89IX
GKbtABEBAAGJAiUEGAECAA8FAlNJ1z8CGwwFCQlmAYAACgkQ7Xj49TUtjt8ymA//
c4lKZQ0oa+m3ADOTss/AKwh3o9v8G5Fj7Q3I2rHywc3ntCbTXmKrmSVugoFQcqOi
x/WosP+ip8FnM3iFUcO6IZO6SznDOCiJnQGNmuksuoikZvRl1bdBsY6fHkwvHEbp
rNQ/vwlNpbt3vt6Z8/bpsc2DTlSmBiUDFPxt5kJzgXZtssuOyHncPTFf3OViL1Qt
4aOpkO2nOoA8ZtgUyp5IRI/XjokxD+xvyjmZ0skRb5Qv+c9xJovO7roCPM+ehOoV
OgD1lFZ+KPlPwLR5MG6N6V8pmt7ryp/qsoulRYdcurGO5jPENMIGEoUqoWUPUhT/
X+zeXZxDW8R8eyYu1kCZDgiqM6vBT8EEg0JEtdq3HXDwpZRDO8CugU5e/+5uFTrZ
7hHDzJlu05xofWsFlSgKg0kFZfaaIYUtCu5RiKswSKl1IDgBSp9yFn54Q9KHabtV
fv1xv4w5I2Zdrm1QVLwzaFPU3Wx1zxNQ6RyTd9AgYm0/TrOSqgY3ky1pY0XBlmbI
fZnVajqYAw5bI7TBYO1gUOvNj9sEBnavp2iJLyioTHG/Rq7rH9Mzi+LRzyd+gjeq
k1DjYF1uJlKA9vCqZkC83E6/63lCs6j6qkXIJzzVLHQgL2mJSmXYqDy/6f3mNZJ1
QbKkOBkEb5PJHi+EKL1QawPeOWcy2jt+IJuHL5wZQDM=
=PDps
-----END PGP PUBLIC KEY BLOCK-----
pub   4096R/CF9730D3 2014-06-10
uid                  Chris Riccomini (CODE SIGNING KEY) <criccomini@apache.org>
sig 3        CF9730D3 2014-06-10  Chris Riccomini (CODE SIGNING KEY) <criccomini@apache.org>
sub   4096R/BB490713 2014-06-10
sig          CF9730D3 2014-06-10  Chris Riccomini (CODE SIGNING KEY) <criccomini@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG/MacGPG2 v2.0.22 (Darwin)
Comment: GPGTools - https://gpgtools.org
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=yVrO
-----END PGP PUBLIC KEY BLOCK-----
pub   4096R/EA00BA80 2015-03-24 [expires: 2020-03-22]
uid                  Yan Fang (CODE SIGNING KEY) <yanfang@apache.org>
sig 3        EA00BA80 2015-03-24  Yan Fang (CODE SIGNING KEY) <yanfang@apache.org>
sub   4096R/E3F3DAD3 2015-03-24 [expires: 2020-03-22]
sig          EA00BA80 2015-03-24  Yan Fang (CODE SIGNING KEY) <yanfang@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG/MacGPG2 v2.0.20 (Darwin)
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=h097
-----END PGP PUBLIC KEY BLOCK-----
pub   4096R/911402D8 2015-06-17
uid       [ultimate] Yi Pan (Samza Release GPG Key) <nickpan47@gmail.com>
sig 3        911402D8 2015-06-17  Yi Pan (Samza Release GPG Key) <nickpan47@gmail.com>
sub   4096R/CC7BEE9E 2015-06-17
sig          911402D8 2015-06-17  Yi Pan (Samza Release GPG Key) <nickpan47@gmail.com>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Comment: GPGTools - https://gpgtools.org

mQINBFWCCEsBEAC7C+Vzz+oPioeyA+9ki7kM9AH/pHHxdUlp7QajOCkjQbN7iQ3b
Sy3kVnLlTV9beJmHR9eFubh5iMZuGedtjMzshWrfdhqq+m2NZEaD0vhdw8uW4ZXS
ttL/I6uHrzb/USXyLfzAaEduh8AZnfjhoTD5Gf6goPucZVB73RNqC/cOWf5ypdRV
qU5idM9slUjqNYO2V4WR/Bbyu9oR0V9DU/Oo3a4e67eyH+iAIxYlXwE/xacsGnXf
td1WT3MmjCuDxiL8VhG4VVOwjeBG8niEJaKLe9n/xwISjg5eS3AtfJvrfXTaYzBI
ph5yRHJ0C4q/6kKceCyGaXGh4bpMbCjhaHtXOptbrp/1ch4qFgnCO8BxcFkRmMI/
qocyX1ejPSRC/Xu61if3WHNd6gRsX6rax/igPz6zDSAf3CRKLJfIAdA+uD7o38N1
yj7aPOMxtzCFcMbHXA0ulMh0lB/j3AtbjkyyMugD2ytYAyZL6Cjvme/Gmddm9oQr
AnWbXuzcjiFLjkmrmDIR6GP+1/7n8aMuKqUsmaUQ59yTot6FdoKprWTNeEVBLAQA
A7yCUZ8ZWnYS1hbS7xSO0gLuBqHdbIlIrWtqHqsok9GHVqwHQEi156+KyN8piva6
h8CMwqiJ7KpVH8FUX4eo31+X1+auU1o4r5YPLPZpvvGBK+k2YkPxeWgcsQARAQAB
tDRZaSBQYW4gKFNhbXphIFJlbGVhc2UgR1BHIEtleSkgPG5pY2twYW40N0BnbWFp
bC5jb20+iQI3BBMBCgAhBQJVgghLAhsDBQsJCAcDBRUKCQgLBRYCAwEAAh4BAheA
AAoJEPjCyRSRFALYVFAP/2kbOGympW+2IvUU2hXvVsjseDSO6k6KdUz4mOxhjQDN
xzyf1Naol6Xk0sOdutSnfNBXI3mJEQPdNanqZkp1/tdbXMgAjbt/TnhpFoErWc1X
QkdgDDT3SRSgmv6H0Gc7d5C5L6FkIkVIJtYws86Je3123C9jopuG4Vs3XapyjWdK
PTIv74ZieQoEcqgva06rnSgNfaUdcsuaS+6TBSbTP6vhEdtmCeu3aO94z4PdGgb8
xRVUItLQuWL68kTkVWR+iP0XWry1nvcTTYBzEGQmKg4cdRwV8Da3smjyC4gWqckx
MvDQaeV/U4WExB+1ul/MFJb7n6yo8zoEL1JclfnufXydL7dRIRT+4po4sg0A4K9g
KtNKEhZTE0AXerzOq/b1pETZdcvfDVI/ML7f0MJi6AfsWKqGvBEPu71eExOrTjpn
MFbDUJflk7/7Uhw0WvA0E4x/9N7olzFczk4Vdcbe88zhOiwTU9NWKS5r0acUxTjQ
IQjhopjaMX/dWZM1aX20ISaONd4LuEwuUeyRdmuOXQdErTAOQSVAYg2praaB3L3X
QXsO2AwAYK2Kd21B7ThSPFI1DyqnVBbODYqKSm6kGVzm97nq0abLsqpOfmYPLT5k
8F5Lj3ZiNigeKNzo8B/YL5dkPDxTxiHUBkKtFqLX3ss0pF1Es11yHrM2d6AGpFyb
uQINBFWCCEsBEACx7f7TpZC02rOFtKY3+XVg9AM1J7H03FnZG33yTnLc4cNX0DJ2
rfj+v8I8VnZV7BcSPUpDdWU4XnCYTT18axqxOkxpb/byZpRFa/nF913IDA6LqHSG
QtkUo4UVGMYiSAYHcClBA1cW8wa3gWItDBcJwVtFeObCttD8CZgGaYmXcAbm0xYT
fT5RH/A/Zjj4oer6AoiKELQNz0zlYni2hvt7+NHJjN+hVBEOjWmFr9kdKRtGKCRl
FbltV7sl5ySJLgNVW2Ai765w4r/T/lo8L+QDqPnO3AED4gZpzLv1HN9k+M67B86o
/A9UfXSRHWrv2wQTgiU4gmGlDrnOn+t/uJN1s751wTDiBtbTwO7iSRaU8VTkYKtg
BHqO5g6N40BCeCl0tpCYdVXLnhQ6VkKWoL7pUsMS7YlU1YODDgQnZ/VLQGk0Q4jz
cf5lpD8du7vIEpk5bGjabdip9JiQSdYzf+pwmJ01xeJyfTfDEh1kp1VYDU3N+Rew
Bfzh97M6BAZRZ1DjPAWKtQwsm111Gg4LGl40/pU3m/kdUifz43mF3jxhGcr8FT3C
k/8mWRVVVw3wHlCFy/j6UA7RMfT91mAToprQg+uRWFbB3/0P4DHh1J/OTf8MMtsC
nG1PWAGvK/49Ugs/uE1Op7gjLv9OmcR8QEwJEr2ZPphiIEDPpF8wqqbg9wARAQAB
iQIfBBgBCgAJBQJVgghLAhsMAAoJEPjCyRSRFALYXvoP/jtNKARPmrjyXptTsT6R
STGvw34rKnkUyahotLystypgeBiTan6wr2nEiI1Qap3xZ0FjBod9Mi8S47jVLsTv
gd3k43aJSWT0fBmnVspr5ObKdOcE8nnxznFCwReSWE4SaDU6hzHAuWak8wj+m43l
HQoReoLQy3LXLzea4HdIfj4ft2/nYhaLVeBNR8aa+o8lsVqyzikgTprT+/qxNoZB
Lo4Ibhggwr7UQqQ6h7kX4AAUBoeaqZDd/DBqQTMF0g3KnXXfqPKwbd9sDqECHwrv
1I+XgJEpvEEEBg9ssHtOnOqWnh4XJzp8HVjcQ5kPnbgkTpouk+s0u4+H/sKtuStJ
vmC1gsmAc10AVyUNyCXM8hEE2xBsZmD07ud9GDrYtyGYJsBidY+sEhERfie4WM5n
iuw1ls5obduGXyCDsqmF5pAnpA6y92m1x+yHOSWT6p+vBTT89vpyPffS5sz0BMCv
oxtwovzz+5IZg4Qo9Hs8EcLazIMFeDpxl5bYJN1Uacw8zGUh3sWnbCwamUKVqsL6
tTA8AJPz8EDJCP6HAIwMVO6wufCPzN7kiFnonUqdsyN+EYVnbm3Lpa/RgnOV3vNa
ggcqLBtFdnTSb+i4eC4MPtvGhZh5rwqw+KX4R58P/BfHGEOzr/b635zKMbZVPgkZ
GuaKTYlQ++u1hns8Jv1+WF+r
=Exd7
-----END PGP PUBLIC KEY BLOCK-----
pub   4096R/2D8D71A2 2015-06-17
uid                  Guozhang Wang <wangguoz@gmail.com>
sig 3        2D8D71A2 2015-06-17  Guozhang Wang <wangguoz@gmail.com>
sub   4096R/0A6EBD79 2015-06-17
sig          2D8D71A2 2015-06-17  Guozhang Wang <wangguoz@gmail.com>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v2.0.14 (GNU/Linux)
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=wAuo
-----END PGP PUBLIC KEY BLOCK-----
pub   4096R/331C8F69 2015-11-20
uid       [ultimate] Navina Ramesh (Code Signing Key) <navina@apache.org>
sig 3        331C8F69 2015-11-20  Navina Ramesh (Code Signing Key) <navina@apache.org>
sub   4096R/0EA9A4A5 2015-11-20
sig          331C8F69 2015-11-20  Navina Ramesh (Code Signing Key) <navina@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Comment: GPGTools - https://gpgtools.org
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=EfEO
-----END PGP PUBLIC KEY BLOCK-----
pub   2048R/C31D7061 2016-09-26
uid                  Xinyu Liu <xinyu@apache.org>
sig 3        C31D7061 2016-09-26  Xinyu Liu <xinyu@apache.org>
sub   2048R/2503DD9D 2016-09-26
sig          C31D7061 2016-09-26  Xinyu Liu <xinyu@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v2.0.14 (GNU/Linux)

mQENBFfpY1YBCACfJ93s0tHvc0fvQrJBmWBvldp6EjQfZZ6N6RSnE8VQZ+w4QpCO
pwiDv+BgoqolKaUprg7xIhHw5kKumY+VRWbDrbNFc1Gc25fZOd6h0S+hsqvuMnzr
g186GsUSwAukLr3hNrv+Q2aQ79OZSyi/q0xD2t7R16OKa4AXMisYDvSQJp46r/7G
7X8Qe7ysqEyKbAJugfJpFeND17vupDob/hEMXvYkvGDfjD2Tyy/zhV7sZsrUNIHx
iL8M5MDAGvSJPYsDif3sR54HXvqUd1+awo6aCAuua/zRccaeNjCpajCUH6vDf0Vr
JBPZ/iZuTndtXMkFL44GYHf8wKa9pyyVIubvABEBAAG0HFhpbnl1IExpdSA8eGlu
eXVAYXBhY2hlLm9yZz6JATgEEwECACIFAlfpY1YCGwMGCwkIBwMCBhUIAgkKCwQW
AgMBAh4BAheAAAoJEDWWQ4nDHXBh0xEH/1wugd7Cbs1ShHBuwbA2/PC3MXARUZ/N
SF7rXPh3a0HWyqZc54dfQKhssJ9nr0XEr/deeHaBWjtTcu3Ez681/FSec9hTHnbo
Fs/CBZXsJH1eLWNkMbsi5t/OZQFgDOMOqZqnPthZOY+sFBSCNCBuZrPFV6fOTXr0
GH+8QLp2fhIgNgiNIENjfWEgdVe3Lnyjs1AMe8Gbj5FWzEGIZj3lMnDalqTdgtcB
H1sFxhI/ncUcE5bglQ3AdQBxBSIvdJhceQhvxy5MewA9cTy/5GYs8I2FC+3sTb2X
uDqnUComfdY0VuEz95nOlCfTmpquP8UyCtvfOtQWfXNSjYegXrhDEla5AQ0EV+lj
VgEIANjbPTgDXW61E+fs2QtCcMDRmRBkNc/W2xFxRvQscFABh+DH6lGRAn7zzJbp
Pocw84ag+oCq0LyLKVnJyzJy2UQKlC6VpDga25XkQBpVQ/bLJ2R7CWU2FXWYp8oL
FmSk5lIW8AmnbQALYk8WFgIu3dJZ8HUeLG1N0eGuHwt0uGhccCvozmJhUa8OrPKZ
CJV2l9wALN/QCaIVcIu9fJUtBdHNUqzpkkpHKox2W1FDQVViQzqHDkTpz9saoyCA
PPNhCnPqbTgMjznaNkggLsU+zz7IKsTigIyVq/9ZzgSqrjKmLh1XwAd2cO7dOuNj
cl8yJmwgxPzsUqBfCf1lu3mSwAkAEQEAAYkBHwQYAQIACQUCV+ljVgIbDAAKCRA1
lkOJwx1wYaDKB/0R4ESymIn64aZ+uOnhYDvie6Vx2adZ3Wn4oJMPeSfHrzM2S2rO
e+3zJQXldIjB4XV9qGHg1goz7Er40yZZJyGSDGY0EpmeUOz23WDad+e1jQG2AHYN
eczBj72LEZFf82C+jij2c72SX/+ThIdKtbNd30dqcWvi+T0I2ca11ULJ5/1VOAMK
sAztvBdl2AtcJnvqjyUngkUb5TprCMGuoqEHeXGiVzw4wpFagLj6wRgW5CUiG0oh
Bc98//GzOjSf5nEiuy3CeeIh8uQzMqQbkUFZqSGuYsRsfTrEBod0yig47CRU6Tz1
KVv5oy0NGj1TibypUsM/QjkwhUlQBj9ctQ7e
=TtlL
-----END PGP PUBLIC KEY BLOCK-----
pub   4096R/AF81FFBF 2017-02-01 [expires: 2021-02-01]
uid       [ultimate] Jagadish Venkatraman <jagadish@apache.org>
sig 3        AF81FFBF 2017-02-01  Jagadish Venkatraman <jagadish@apache.org>
sub   4096R/57C790D3 2017-02-01 [expires: 2021-02-01]
sig          AF81FFBF 2017-02-01  Jagadish Venkatraman <jagadish@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
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=/o0l
-----END PGP PUBLIC KEY BLOCK-----

pub   4096R/940AFC5A 2017-06-01 [expires: 2021-06-01]
uid       [ultimate] Jake Maes <jmakes@apache.org>
sig 3        940AFC5A 2017-06-01  Jake Maes <jmakes@apache.org>
sub   4096R/D6B6587F 2017-06-01 [expires: 2021-06-01]
sig          940AFC5A 2017-06-01  Jake Maes <jmakes@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
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=66aV
-----END PGP PUBLIC KEY BLOCK-----
pub   4096R/A211312E 2017-08-15 [expires: 2021-08-15]
uid       [ultimate] Fred Ji <haifeng.ji@gmail.com>
sig 3        A211312E 2017-08-15  Fred Ji <haifeng.ji@gmail.com>
sub   4096R/BCE71616 2017-08-15 [expires: 2021-08-15]
sig          A211312E 2017-08-15  Fred Ji <haifeng.ji@gmail.com>

-----BEGIN PGP PUBLIC KEY BLOCK-----

mQINBFmTSN8BEACpkPAUsmaRBkgGvnU6E6Dnv9UzZHVHJaDctVO6xLi1wnbTPyaN
tz9MJx3hyYuy/rKh/l3TWLPTvYlwO6PmaXz2DlMRvIWVdztdB87up8XNjXCeDrtv
SbAezRnPelqx5gsyZ3tgtLOmxXmFmrpa3fqrnIvG22xf0N3+AYhOdEDGzHWiSAjF
9RUiCWQHLPeQHOlUO7nhK90kkBYamSREJpggpzouwuHiew+MzcIji2U/vPStHmOd
QVfQZcFnLO6Jp0FLCHxGtFFqhUYc2mgtUK/NExto5PEWHAdFuBr1FY3F5PbcZl+y
DkWCVbWkfEi/UZ/L5fH5VlMrYynWSQKOmKgPVnYUGfQpU0nHUC8TQVDxrXQV8TKv
6FV9TlW2rJbAjTCp76EGG7rcGFtgiZ1RkJf8WI7FHDD7VS2EgKmJCFoekA4J9pro
EbHEtQohYzuMgTNmbNZN2vc8iMxHN+YDrlOxElDOjAtLl6OeBw16FBcp+mksKmHR
3FXYFRM+S+WrB+jmiIwolbWpSsQ6whcqSx/P1N/yiX/6PjozkkhulGVcbh7gLhRF
p0DCFs3MIXt7qKjgPEnEiKJ0zlyT2ODmTT2biYLsCwfCEQ92Fzg7PCrDevqMSxFP
0JU5w4QtLTP6/oYSf1fS7f8iynI8v/pgQDFdGARcYJ5suBkVRST6aG5VCwARAQAB
tB5GcmVkIEppIDxoYWlmZW5nLmppQGdtYWlsLmNvbT6JAj0EEwEKACcFAlmTSN8C
GwMFCQeGH4AFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQ7f2PmqIRMS7fCBAA
gvJA7z0D7VIxin7WOQdBt7+C2Mt6bkYhEDSW7z1yYju8T8zg5N7nY5b9zMMtmATg
f/cMuKP3Zu7Ztf0QOU9hHQ0NFZA5Ejx3KwKL3ozTmH8Zlq7PJy03ydSfYgbEyKbD
LBBdx6hTn3P16qqofAfPA8/zaXWzuOtp5f7sIN0aPEiLUAL3RoplLrCCJGvJrUyl
Qj7YKa6/nfJOMR2vGl1sU4vzVwjcO/uJ1ohqzYPE8+FgESzr6V6kQb0JB9fs9XXc
9dThBHZx0L7WmTyMbX9sfYilnXQV9Gw+poc0i0UUM5UoS7lRq7EW7EdC6TTJzafE
CKP6BxLvYgzHJJfsM0oBiddodooKjrkfLS0fHaBCPP5FpP5YLZhiyu1r9PvblCHV
eEKjhGb11tWBcza0eLpl8VUc79p0R+hpkhYcJAQ6hnSQvd0+g5qP0MmGop3M+g3D
wG0YoplWoIAyzmUXxekbDgswDYDYQtKgtwjxWXmkkN4Wj/Wzxoi/3xJNapehdGqZ
M00w+Lni92U8wRMu5PMtvj8M6oNdCZw2aCpOw5+CdAyp9rKCvM3sCuj9y6qNdgSC
8vEAN7bOg4f5JMia3bDHzQpfw4ZG7TdVHfNYJML7WA9n3PZ3TNpkHyc4Dh5Gxa8p
2rsH8c+wreH0F1tIbly1lqcdtP3374LS35xp7TShAjW5Ag0EWZNI3wEQAMWLLWZV
rFVMhtc0Pb/edJVzK7X+PCm10vjd5u+hz2PkOKjR1CKhcUrWdX1tbQ45wZWqy4Or
K8kHLUTep22wGoKfqJ6X9elN0/yv3mIhQg1VJ/5EGPevBrx7h2ABQ/a4W2x2OGZB
ncDSos8pmDYrSlqZ+kNDqJNQxa0P2feV2swJi3Ygj1DT8DaHQgQ/MNoAHDcUULCV
cCQuS8dbDkEEs27rEJRG0cvI2+0cpqn36zZjWuFprg4qfrL0grkv+XkpgLzArsFU
dND186as6ZrThlq0ZOmeadP6Z2d259X3OG4+wQVK2WrSo6OUIOZz1KQ+om3yQy81
t5dYyNfOJ/KPCATHKpdBBR5HRUtgE8nNg3nn5eTCjQzD6nwNE6zuHXwhx03UlbQN
tTwQRYU6ADG+ZybUuPZpTLRvd+5q5t5E4GZdbWaKoLz/j3Qe253UddyEX2QDNJjF
Hvws6Qxc4mlQjLl4uLPMzo/pvIclD44PV3IMWyVq8dGiIBgyl7DKCLm1sqV/Kw7Y
fWpZu1sRvM37PLZJWL+PQZJCacWZnz8i8vc3x3+BhEQosZrNKyA5s5IRE2ox0eOS
9S1sOP7mNnYhlnyevuWyRD+0vxkVnHzqCMRLYkdBZEHlakFEWPbSKJ9cFBuf8zfZ
KUlKZoZL2R2v5lNhYcyiAaS+Vz1w84D8lN6NABEBAAGJAiUEGAEKAA8FAlmTSN8C
GwwFCQeGH4AACgkQ7f2PmqIRMS6DuhAAmfE5gIaPpYvOg9kU3OFRN7tk3ZJq3tjj
uDXKyvfOi7rg2kLXuCiXtWT9B6pqNVZt+qi65RRHciNA8o7oTG6PLsykXSYrl9ok
XtWPGq1yMkQS7fZpyBI+G/VJIR4fIQgWXIZgJvgvCdmLbXqlJ3mnOr/cP0MB1yXE
5vpAWJmHGA9i9WeR+qmjUJ8zxm80ap/u2lPjtE955jS+w/gS9foL6Q+r7uKEhVlc
gsR0sAtME/MZJ9DCcAcRdUw151vfctq5Ro7SwhRuxWc4E3QbFDoT7ivb9YeIx9AE
fWbPFsRJPSY22jNNSZi5PFd2naLAuC+rQ10F1trGr+JnlVOU49YaLbVYl6HbbIde
Sxlr57aIfkDoJsoIpXGq1NcBiOuCDhO/1ODHFWFY0b8LYzSrB4Frzr9ZKtHBnaQ7
bqRSoSWbtv2DnDlvqEBnC6TImaSlHa/RUQVouKUga8SQ9Z0QDoNapfW7f5rt7IGs
vaxQlMGlbMfCJB8Pw69dDx9eqKkjw8IoKItxFKMy28Mv43MgzMNDjjbPeNOLFV9M
UyR9daQyCWQbu+UWn67OBUxJBnJGDjzcIoEKsFU+xt/GkExBXzL4JxiXFS+cv3dg
P83WClBM5LS+ArY8Z81uX751Sh8JtNEGzdRS2jR3s+cBGsH37XdPceVCUTFLGL/d
C+FsNOOomcE=
=3dsB
-----END PGP PUBLIC KEY BLOCK-----
pub   rsa2048 2017-10-03 [SC] [expires: 2019-10-03]
      71B65FE229D85324359D00283EBF0CDA6585B3D7
uid           [ultimate] Prateek Maheshwari <pmaheshwari@apache.org>
sig 3        3EBF0CDA6585B3D7 2017-10-03  Prateek Maheshwari <pmaheshwari@apache.org>
sub   rsa2048 2017-10-03 [E] [expires: 2019-10-03]
sig          3EBF0CDA6585B3D7 2017-10-03  Prateek Maheshwari <pmaheshwari@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----

mQENBFnUGh4BCAC3uhNMO2LapZWsrDxvG3RkXvvQa7zxlJpaOphrdMUpWvMvYOoQ
ZHH50Uc70Vh/SW6CcEg6MoPTgNuzjsRxpnC8oyY1mlCnvEsaVMWSMRnn4NvpFvuX
+/CKmEcASDVx+zb7hPFOHgYG1nVOWarhPbw7NrbUtIDQ8cjD3cQ9Szv1RVK1HGff
AbC5Ko/ddcKAqZJadYq2MAAKlnSDWmYR2Iyu5YxMy/Lv0WN/6sZRm/ynEPEO1/PH
4I0h6r1VH/plFEV4P0DeiV6daCjh7Ix66Wt8gy8T/DH3+iR4CkRpg+a9NItJwC5A
/EiiaG31NfjWtBv0hOeE4rAv1y/WRx52c0oPABEBAAG0K1ByYXRlZWsgTWFoZXNo
d2FyaSA8cG1haGVzaHdhcmlAYXBhY2hlLm9yZz6JAVQEEwEIAD4WIQRxtl/iKdhT
JDWdACg+vwzaZYWz1wUCWdQaHgIbAwUJA8JnAAULCQgHAgYVCAkKCwIEFgIDAQIe
AQIXgAAKCRA+vwzaZYWz173hB/99BrM6vnYoRByrpbiGEmY+tpEJRRJw+hlsV98E
4+a7hurWUAuqMhf2QmObknG4X5EORikaFkAcmJtaShvJV6CSv/c77DHkmihMdNj4
lzut3K2IY3Lv6lgohX2zchuW/dXYTxhqkJUUpi+uo/KV1X/K8wJAA1o6AlvdbXwv
uTOWs2oz0tKVAbkzo6KA/IIUf/8sWJLfVignFZ9xcRDnHrRRDJBIPMfZvbxCjXCe
drGUXyRoqdHyNzk/SNCMeFnkkl0oZF0+hw/uXBUaDNcRq4kfv+S0Z0EmTFEB2wDi
Uxoc+V9nMj4osWdOUh+RDDCsEv10nfFczHaJdNxIn0EcM05nuQENBFnUGh4BCADS
G4Lge9ws0pyQkZBhmZG321JpndC83IofOsumOcIAUJ++hkHWvkq5BXO3s8oYP2ti
YfHfaNZbSkGI+0eGGr7uHEQvMA7kxnl6mdMb2oOUxZbPOgZd9gBwo644gF4cYZxy
1MXL3OqC7beKcqfFCvIy3XwYZfxLlCIthkXTUs+SbCTJgkM+0eq2iuRDxDwWOhBu
wBTAQ5HItd6QfMGp/EUkGe1MeawqT7X4YBrfka8St2rT3e+212LSNVxX5M1Vlhj3
5+muDmu/DfFFeQ1W1x11a5TG+qb9vTdWNELMJ7qlrqK7nbhBP5ABnMp/tCt4yCnF
veu7xu+RxRcuDM4+NGdvABEBAAGJATwEGAEIACYWIQRxtl/iKdhTJDWdACg+vwza
ZYWz1wUCWdQaHgIbDAUJA8JnAAAKCRA+vwzaZYWz1+nJCACMFRnMbkcKco+F+RKW
qHLqHx2hRmQQoarjKfImHS31xGE6kRO0MVwRfoS0jaInNAHbSYouTgSJMqo15PNc
8YFb0fjMVklRVU7q7Ty7ouIBji5qYfVIhYOyx8krsGHxoJ6eInx2DqMHheyxCWlY
Qf6fcPd638fEA5xeGnODkVAoWImQsphyr/3Grij9hnsGHWpgmE9B08ULVgBHtm6b
fQ7zwLPXO2k8ah5PU3k1EAQFzZEzJLcw1ypaodPg7Nz3NNybGYVGkNqtpZUcVv97
l3mENVdj5rhkcgRBTnt/ZmY+R1BoNzJVj1WcwZCvRI3zt4G0ZnuHsny5AQq5LZ+T
g2aH
=ukLA
-----END PGP PUBLIC KEY BLOCK-----
pub   2048R/5B5EB041 2019-05-17
uid                  Boris Shkolnik (Key for release signing) <boryas@apache.org>
sig 3        5B5EB041 2019-05-17  Boris Shkolnik (Key for release signing) <boryas@apache.org>
sub   2048R/F77F01B7 2019-05-17
sig          5B5EB041 2019-05-17  Boris Shkolnik (Key for release signing) <boryas@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v2.0.22 (GNU/Linux)

mQENBFze7MEBCADJGw76F2EkwUUjEzxBgBLpg5zbNNTnlwgYJ5C/FVPFILK14H+6
vjN2ID66ZQJCg30w3FltFILgfJhLHjrAabcFbptghqzT0kFCIcrVwiHm7eu7z5C1
faTkBhKc2xiQjjVRp1Jkr/iNcKct9p6wuhABAiiEOI5iKxzN00Nkf2SaPydP8mUa
ftEmpHaVLmVwgW5Jh/tCJIoJn0T06uNMZ7C25DI9TJP9UwXkzzw++b7Drd4hp310
bjrhGb61VU2SbZum4sVi6gNZlXFE0gzfQRLLiTpESPsEaouRmymOG81LaWNbH9+w
xD5Mc+dRSmuLpYpCTUDcbm18bquN846grToFABEBAAG0PEJvcmlzIFNoa29sbmlr
IChLZXkgZm9yIHJlbGVhc2Ugc2lnbmluZykgPGJvcnlhc0BhcGFjaGUub3JnPokB
OQQTAQIAIwUCXN7swQIbAwcLCQgHAwIBBhUIAgkKCwQWAgMBAh4BAheAAAoJEH10
0M1bXrBBgScIAINYtGoMSPl3UgNaa1bv124milnaa/E9Mu1dkD3nXCcsn2bRtdM7
oSOxRJ35wHwEEQMWzmEVG+wyxSNdUBaoIAzMV/Ok+yCmKVaPlKINmoUQ2k5RjAle
kyqz0lcaYluSL5GTqlm2Hw+v5uZ78c2O36PwuhydNedfO1aI7msS89zoeyyVtJQz
3M+i/fpZ9mbkbcQWU4Bn1HgcsKYCiyDJ6RCoEvQJheIUNKTswj78IgcppvYHtkDF
NOtUQgw6GozQ0zIVRw7+82qNGkgbPPYjJjfgNuFkgD1GY3Fp4UDs9yX2Qlr0swoP
f0WOqiDbHPln5EHVtVXwK0994NAPSXzS1tu5AQ0EXN7swQEIANZFy99a86nlddQg
sldEmg2fhFJDIk8+SXDm2NF5TeTMQ96KZpaFcyOEy1DytA5EzryIynGgV9rt9jhH
a8HtfH2uiHf3QTIqgnrUimxs2uhxc+Kfx9yfEKaEUBKrnSdrStqxu0DQefbr84KW
VmhEvKSmzejHoqeV4H7Q+/tmCrMbeVDyOKEQLKYm9Dm3TNJxNRqxNrKzdsjYgqt7
B1heSXiKzzREsZSWoXLkFX2H6qJpKn6/Mbdu5qD7RIenYZ1BJDPkAkTTCA1rpr1o
iW2qY7KFzJkFGBnej+G58GcOFwAzIPzzjQsip5XjMedbYpz2V7sdij6K9AO1avDu
1Fb8iEEAEQEAAYkBHwQYAQIACQUCXN7swQIbDAAKCRB9dNDNW16wQY/0CAC7t4c3
cSgsWbEIkdY4A/cNAeQQxWmi08x0UMl1xYGfcIOtAwePdQOJJ2TuhBEJKMLmKO64
IpGzaKwcRaEPBB9lFwJBAJeCizzY76h64LFnus35aA3UJeG3TlyfcggVI5uJG//M
90TVkxv84Z406Wf2B1RLca3YmsxGdchk6JLD9e2bPXGAFgr+z5sTsHAe6XP8CcoH
PlhUDyZhNuP6OnvS0r0qkIy4eWZzsuUk3OuJQAkhvqNb/r5eahXtgpasJyIYofeR
bN7+AsTZ8FGMrkfwrs9a1RFtypldStL70bAl61/yTqngdwFGb0zJi3IxqNzq8Fun
AE4y9/JMEbF0vpC4
=lijy
-----END PGP PUBLIC KEY BLOCK-----
pub   4096R/54CB3CE3 2019-10-02 [expires: 2021-03-25]
uid                  Cameron Lee <cameronlee@apache.org>
sig 3        54CB3CE3 2020-02-10  Cameron Lee <cameronlee@apache.org>
uid                  Cameron Lee (Cameron Lee at LinkedIn) <calee@linkedin.com>
sig 3        54CB3CE3 2019-10-02  Cameron Lee <cameronlee@apache.org>
sub   4096R/0106149F 2019-10-02 [expires: 2021-03-25]
sig          54CB3CE3 2019-10-02  Cameron Lee <cameronlee@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v2.0.22 (GNU/Linux)
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=Ua22
-----END PGP PUBLIC KEY BLOCK-----
pub   rsa4096 2020-02-13 [SC] [expires: 2024-02-13]
      9EBC0889D43FAE16DD0D8F5BA2F50CF4256F8FA2
uid           [ultimate] Hai Lu (key 2020) <lhaiesp@apache.org>
sig 3        A2F50CF4256F8FA2 2020-02-13  Hai Lu (key 2020) <lhaiesp@apache.org>
sub   rsa4096 2020-02-13 [E] [expires: 2024-02-13]
sig          A2F50CF4256F8FA2 2020-02-13  Hai Lu (key 2020) <lhaiesp@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
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=EHog
-----END PGP PUBLIC KEY BLOCK-----
pub   rsa4096 2020-06-02 [SC] [expires: 2022-06-02]
      603B397B5E20757D18BE6C91F3B965A6B192DAB7
uid           [ultimate] Bharath Kumarasubramanian <bharathkk@apache.org>
sig 3        F3B965A6B192DAB7 2020-06-02  Bharath Kumarasubramanian <bharathkk@apache.org>
sub   rsa4096 2020-06-02 [E] [expires: 2022-06-02]
sig          F3B965A6B192DAB7 2020-06-02  Bharath Kumarasubramanian <bharathkk@apache.org>

-----BEGIN PGP PUBLIC KEY BLOCK-----
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=Ja6V
-----END PGP PUBLIC KEY BLOCK-----
