Adrian Cole <acole@.eng.vmware.com>
Adrian Cole <adrian.f.cole@3d8758e0-26b5-11de-8745-db77d3ebf521>
Adrian Cole <adrian.f.cole@gmail.com>
Adrian Cole <ferncam1@3d8758e0-26b5-11de-8745-db77d3ebf521>
Alex Yarmula <oleksiy.yarmula+hosting@gmail.com>
Alfredo Morresi <rainbowbreeze@gmx.com>
Alfredo Morresi <rainbowbreeze@pc-alfredo.(none)>
Andrea Turli <andrea@bigmac.local>
Andrea Turli <andrea.turli@.dir.svc.accenture.com>
Andrea Turli <Andrea_Turli@.dub.emea.dell.com>
Andrea Turli <andrea.turli@gmail.com>
Andrea Turli <toor@toor.(none)>
Andrei Savu <asavu@apache.org>
Andrew Phillips <sharedocs1@gmail.com@3d8758e0-26b5-11de-8745-db77d3ebf521>
Antoni Batchelli <tbatchelli@acm.org>
Barak Merimovich <barakme@gmail.com>
Carlos Sanchez <carlos@apache.org>
Dan Lo Bianco <dan.lobianco@cloudsoftcorp.com>
Dmitry Durnev <ddurnev@griddynamics.com>
Hans Hrasna <hans.hrasna@gmail.com>
Hunter Hutchinson <hunter.hutchinson@gmail.com>
Ilja Bobkevic <ilja.bobkevic@gmail.com>
Ivan Meredith <ivan@ivan.net.nz@3d8758e0-26b5-11de-8745-db77d3ebf521>
James Murty <jamurty@3d8758e0-26b5-11de-8745-db77d3ebf521>
Karthik Ganesan <karthikwrites@yahoo.com>
Nicholas Terry <nterry@familysearch.org>
Nirmal Fernando <nirmal@nirmal.(none)>
Seshu Pasam <github@pasam.com>
Shane Witbeck <shane@digitalsanctum.com>
Tibor Kiss <tibor.kiss@omixon.com>
Victor Galkin <vgalkin@griddynamics.net>
Vijay Kiran <mail@vijaykiran.com>
Zack Shoylev <zack.shoylev@rackspace.com>
