# Names should be added to this file with this pattern:
#
# For individuals:
#   Name <email address>
#
# For organizations:
#   Organization <fnmatch pattern>
#
# See python fnmatch module documentation for more information.

Aaron Boushley <boushley@gmail.com>
Aaron Jacobs <samusaaron3@gmail.com>
Aaron Leventhal <aaronlevbugs@gmail.com>
Aaron Randolph <aaron.randolph@gmail.com>
Aaryaman Vasishta <jem456.vasishta@gmail.com>
Abdu Ameen <abdu.ameen000@gmail.com>
Abhijeet Kandalkar <abhijeet.k@samsung.com>
Abhishek Agarwal <abhishek.a21@samsung.com>
Abhishek Kanike <abhishek.ka@samsung.com>
Abhishek Singh <abhi.rathore@samsung.com>
Adam Bonner <abonner-chromium@solscope.com>
Adam Bujalski <abujalski@gmail.com>
Adam Kallai <kadam@inf.u-szeged.hu>
Adam Roben <adam@github.com>
Adam Treat <adam.treat@samsung.com>
Adam Yi <i@adamyi.com>
Addanki Gandhi Kishor <kishor.ag@samsung.com>
Adenilson Cavalcanti <a.cavalcanti@samsung.com>
Aditya Bhargava <heuristicist@gmail.com>
Adrian Belgun <adrian.belgun@intel.com>
Ahmet Emir Ercin <ahmetemiremir@gmail.com>
Ajay Berwal <a.berwal@samsung.com>
Ajay Berwal <ajay.berwal@samsung.com>
Ajith Kumar V <ajith.v@samsung.com>
Aku Kotkavuo <a.kotkavuo@partner.samsung.com>
Aldo Culquicondor <alculquicondor@gmail.com>
Aleksandar Stojiljkovic <aleksandar.stojiljkovic@intel.com>
Alex Gabriel <minilogo@gmail.com>
Alex Gartrell <agartrell@cmu.edu>
Alex Henrie <alexhenrie24@gmail.com>
Alex Scheele <alexscheele@gmail.com>
Alexander Douglas <agdoug@amazon.com>
Alexander Guettler <alexander@guettler.io>
Alexander Shalamov <alexander.shalamov@intel.com>
Alexander Sulfrian <alexander@sulfrian.net>
Alexandre Abreu <wiss1976@gmail.com>
Alexandru Chiculita <achicu@adobe.com>
Alexey Korepanov <alexkorep@gmail.com>
Alexey Kuts <kruntuid@gmail.com>
Alexey Kuzmin <alex.s.kuzmin@gmail.com>
Alexey Kuznetsov <saturas2000@gmail.com>
Alexis Brenon <brenon.alexis@gmail.com>
Alexis La Goutte <alexis.lagoutte@gmail.com>
Alexis Menard <alexis.menard@intel.com>
Alfredo Hernandez <ahernandez.miralles@gmail.com>
Ali Vathi <ali.akbar@gmail.com>
Allan Sandfeld Jensen <allan.jensen@qt.io>
Alper Çakan <alpercakan98@gmail.com>
Ambarish Rapte <ambarish.r@samsung.com>
Amey Jahagirdar <jahagird@amazon.com>
Amit Sarkar <amit.srkr@samsung.com>
Amogh Bihani <amogh.bihani@samsung.com>
Amos Lim <amoseui@gmail.com>
Amos Lim <eui-sang.lim@samsung.com>
Amruth Raj <amruthraj@motorola.com>
Amruth Raj <ckqr36@motorola.com>
Anand Ratn <anand.ratn@samsung.com>
Anastasios Cassiotis <tom.cassiotis@gmail.com>
anatoly techtonik <techtonik@gmail.com>
Ancil George <ancilgeorge@samsung.com>
Andra Paraschiv <andra.paraschiv@intel.com>
Andrei Borza <andrei.borza@gmail.com>
Andrei Parvu <andrei.prv@gmail.com>
Andrei Parvu <parvu@adobe.com>
Andrew Boyarshin <andrew.boyarshin@gmail.com>
Andrew Brampton <me@bramp.net>
Andrew Brindamour <abrindamour@bluejeans.com>
Andrew Hung <andrhung@amazon.com>
Andrew Jorgensen <ajorgens@amazon.com>
Andrew MacPherson <andrew.macpherson@soundtrap.com>
Andrew Tulloch <andrew@tullo.ch>
Anish Patankar <anish.p@samsung.com>
Ankit Kumar <ankit2.kumar@samsung.com>
Ankur Verma <ankur1.verma@samsung.com>
Anna Henningsen <anna@addaleax.net>
Anne Kao <annekao94@gmail.com>
Anssi Hannula <anssi.hannula@iki.fi>
Anthony Halliday <anth.halliday12@gmail.com>
Anton Obzhirov <a.obzhirov@samsung.com>
Antonin Hildebrand <antonin.hildebrand@gmail.com>
Antonio Gomes <a1.gomes@sisa.samsung.com>
Anuj Kumar Sharma <anujk.sharma@samsung.com>
Arjun Karthik <arjunkar@amazon.com>
Arman Ghotb <armanghotb@gmail.com>
Armin Burgmeier <aburgmeier@bloomberg.net>
Arnaud Mandy <arnaud.mandy@intel.com>
Arnaud Renevier <a.renevier@samsung.com>
Arpita Bahuguna <a.bah@samsung.com>
Arthur Lussos <developer0420@gmail.com>
Arun Kulkarni <kulkarni.a@samsung.com>
Arun Kumar <arun87.kumar@samsung.com>
Arun Mankuzhi <arun.m@samsung.com>
Arunoday Sarkar <a.sarkar.arun@gmail.com>
Arunprasad Rajkumar <ararunprasad@gmail.com>
Arunprasad Rajkumar <arurajku@cisco.com>
Asami Doi <d0iasm.pub@gmail.com>
Ashish Kumar Gupta <guptaag@amazon.com>
Ashlin Joseph <ashlin.j@samsung.com>
Asish Singh <asish.singh@samsung.com>
Attila Dusnoki <dati91@gmail.com>
Avinaash Doreswamy <avi.nitk@samsung.com>
Ayush Khandelwal <k.ayush@samsung.com>
Azhar Shaikh <azhar.shaikh@intel.com>
Balazs Kelemen <b.kelemen@samsung.com>
Baul Eun <baul.eun@samsung.com>
Behara Mani Shyam Patro <behara.ms@samsung.com>
Bem Jones-Bey <bemajaniman@gmail.com>
Bem Jones-Bey <bjonesbe@adobe.com>
Ben Coe <bencoe@gmail.com>
Ben Fiola <benfiola@gmail.com>
Ben Karel <eschew@gmail.com>
Ben Noordhuis <ben@strongloop.com>
Benedek Heilig <benecene@gmail.com>
Benjamin Dupont <bedupont@cisco.com>
Benjamin Jemlich <pcgod99@gmail.com>
Bernard Cafarelli <voyageur@gentoo.org>
Bernhard M. Wiedemann <bwiedemann@suse.de>
Bert Belder <bertbelder@gmail.com>
Bhagirathi Satpathy <bhagirathi.s@samsung.com>
Bhanukrushana Rout <b.rout@samsung.com>
Biljith Jayan <billy.jayan@samsung.com>
Boaz Sender <boaz@bocoup.com>
Bobby Powers <bobbypowers@gmail.com>
Branden Archer <bma4@zips.uakron.edu>
Brendan Kirby <brendan.kirby@imgtec.com>
Brendan Long <self@brendanlong.com>
Brian G. Merrell <bgmerrell@gmail.com>
Brian Konzman, SJ <b.g.konzman@gmail.com>
Brian Luft <brian@electroly.com>
Brian Merrell, Novell Inc. <bgmerrell@gmail.com>
Brian Yip <itsbriany@gmail.com>
Bruno Calvignac <bruno@flock.com>
Bruno de Oliveira Abinader <brunoabinader@gmail.com>
Bruno Roy <brusi_roy@hotmail.com>
Bryan Donlan <bdonlan@gmail.com>
Bryce Thomas <bryct@amazon.com>
Burton <burton@typewritten.net>
Byounghoon Yoon <bill.2714@kakaocorp.com>
Byoungkwon Ko <codeimpl@gmail.com>
Byungwoo Lee <bw80.lee@samsung.com>
Caesar Wang <wxt@rock-chips.com>
Caio Marcelo de Oliveira Filho <caio.de.oliveira.filho@intel.com>
Caitlin Potter <caitpotter88@gmail.com>
Calvin Mei <calvimei@amazon.com>
Cameron Gutman <aicommander@gmail.com>
Catalin Badea <badea@adobe.com>
Cathie Chen <cathiechen@tencent.com>
Cem Kocagil <cem.kocagil@gmail.com>
Chakshu Ahuja <chakshu.a@samsung.com>
Chamal De Silva <chamalsl@yahoo.com>
Chandan Padhi <c.padhi@samsung.com>
Chandra Shekar Vallala <brk376@motorola.com>
Chandramouli Sanchi <cm.sanchi@samsung.com>
Chang Shu <c.shu@samsung.com>
Changbin Shao <changbin.shao@intel.com>
Changjun Yang <changjun.yang@intel.com>
ChangSeok Oh <shivamidow@gmail.com>
Changwan Hong <changwan.hong@navercorp.com>
Changyeon Kim <cyzero.kim@samsung.com>
Chanho Park <parkch98@gmail.com>
Chansik Yun <chansik.yun@gmail.com>
Chaobin Zhang <zhchbin@gmail.com>
Charles Vaughn <cvaughn@gmail.com>
Choongwoo Han <cwhan.tunz@gmail.com>
Chris Greene <cwgreene@amazon.com>
Chris Harrelson <chrishtr@gmail.com>
Chris Nardi <hichris123@gmail.com>
Chris Szurgot <szurgotc@amazon.com>
Chris Tserng <tserng@amazon.com>
Chris Vasselli <clindsay@gmail.com>
Christophe Dumez <ch.dumez@samsung.com>
Christopher Dale <chrelad@gmail.com>
Claudio DeSouza <claudiomdsjr@gmail.com>
Clemens Fruhwirth <clemens@endorphin.org>
Clement Scheelfeldt Skau <clementskau@gmail.com>
Clinton Staley <clintstaley@gmail.com>
Connor Pearson <cjp822@gmail.com>
Conrad Irwin <conrad.irwin@gmail.com>
Craig Schlenter <craig.schlenter@gmail.com>
Csaba Osztrogonác <ossy.szeged@gmail.com>
Daegyu Lee <na7jun8gi@gmail.com>
Dai Chunyang <chunyang.dai@intel.com>
Daiwei Li <daiweili@suitabletech.com>
Damien Marié <damien@dam.io>
Dan McCombs <overridex@gmail.com>
Daniel Bevenius <daniel.bevenius@gmail.com>
Daniel Bomar <dbdaniel42@gmail.com>
Daniel Carvalho Liedke <dliedke@gmail.com>
Daniel Charles <daniel.charles@intel.com>
Daniel Imms <daniimms@amazon.com>
Daniel Johnson <danielj41@gmail.com>
Daniel Lockyer <thisisdaniellockyer@gmail.com>
Daniel Nishi <dhnishi@gmail.com>
Daniel Platz <daplatz@googlemail.com>
Daniel Shaulov <dshaulov@ptc.com>
Daniel Trebbien <dtrebbien@gmail.com>
Daniel Waxweiler <daniel.waxweiler@gmail.com>
Dániel Bátyai <dbatyai@inf.u-szeged.hu>
Dániel Vince <vinced@inf.u-szeged.hu>
Darshini KN <kn.darshini@samsung.com>
Dave Barker <kzar@kzar.co.uk>
David Benjamin <davidben@mit.edu>
David Davidovic <david@davidovic.io>
David Erceg <erceg.david@gmail.com>
David Fox <david@davidjfox.com>
David Futcher <david.mike.futcher@gmail.com>
David Leen <davileen@amazon.com>
David McAllister <mcdavid@amazon.com>
David Michael Barr <david.barr@samsung.com>
David Spellman <dspell@amazon.com>
David Valachovic <adenflorian@gmail.com>
Dax Kelson <dkelson@gurulabs.com>
Debashish Samantaray <d.samantaray@samsung.com>
Debug Wang <debugwang@tencent.com>
Deepak Dilip Borade <deepak.db@samsung.com>
Deepak Mittal <deepak.m1@samsung.com>
Deepak Mohan <hop2deep@gmail.com>
Deepak Sharma <deepak.sharma@amd.com>
Deepak Singla <deepak.s@samsung.com>
Deokjin Kim <deokjin81.kim@samsung.com>
Derek Halman <d.halman@gmail.com>
Devlin Cronin <rdevlin.cronin@gmail.com>
Diana Suvorova <diana.suvorova@gmail.com>
Diego Ferreiro Val <elfogris@gmail.com>
Dillon Sellars <dill.sellars@gmail.com>
Divya Bansal <divya.bansal@samsung.com>
Dominic Farolino <domfarolino@gmail.com>
Dominic Jodoin <dominic.jodoin@gmail.com>
Dominik Röttsches <dominik.rottsches@intel.com>
Don Woodward <woodward@adobe.com>
Donghee Na <corona10@gmail.com>
Dong-hee Na <donghee.na92@gmail.com>
Dongie Agnir <dongie.agnir@gmail.com>
Dongjun Kim <djmix.kim@samsung.com>
Dongseong Hwang <dongseong.hwang@intel.com>
Dongwoo Joshua Im <dw.im@samsung.com>
Dongyu Lin <l2d4y3@gmail.com>
Donna Wu <donna.wu@intel.com>
Douglas F. Turner <doug.turner@gmail.com>
Dustin Doloff <doloffd@amazon.com>
Ebrahim Byagowi <ebrahim@gnu.org>
Ebrahim Byagowi <ebraminio@gmail.com>
Eden Wang <nedenwang@tencent.com>
Eduardo Lima (Etrunko) <eblima@gmail.com>
Eduardo Lima (Etrunko) <eduardo.lima@intel.com>
Edward Baker <edward.baker@intel.com>
Edward Crossman <tedoc2000@gmail.com>
Eero Häkkinen <e.hakkinen@samsung.com>
Eero Häkkinen <eero.hakkinen@intel.com>
Egor Starkov <egor.starkov@samsung.com>
Ehsan Akhgari <ehsan.akhgari@gmail.com>
Elan Ruusamäe <elan.ruusamae@gmail.com>
Ergun Erdogmus <erdogmusergun@gmail.com>
Eric Ahn <byungwook.ahn@gmail.com>
Eric Rescorla <ekr@rtfm.com>
Erik Hill <erikghill@gmail.com>
Erik Sjölund <erik.sjolund@gmail.com>
Eriq Augustine <eriq.augustine@gmail.com>
Ernesto Mudu <ernesto.mudu@gmail.com>
Etienne Laurin <etienne@atnnn.com>
Eugene Kim <eugene70kim@gmail.com>
Eugene Sudin <eugene@sudin.pro>
Eunseok Oh <fivesilverstone@gmail.com>
Evan Peterson <evan.peterson.ep@gmail.com>
Evan Wallace <evan.exe@gmail.com>
Evangelos Foutras <evangelos@foutrelis.com>
Evgeniy Dushistov <dushistov@gmail.com>
Evgeny Agafonchikov <evgeny.agafonchikov@akvelon.com>
Fabian Henneke <fabian.henneke@gmail.com>
Fabien Tassin <fta@sofaraway.org>
Felix H. Dahlke <fhd@ubercode.de>
Fengrong Fang <fr.fang@samsung.com>
Fernando Jiménez Moreno <ferjmoreno@gmail.com>
Finbar Crago <finbar.crago@gmail.com>
François Beaufort <beaufort.francois@gmail.com>
Francois Kritzinger <francoisk777@gmail.com>
Francois Rauch <leopardb@gmail.com>
Frankie Dintino <fdintino@theatlantic.com>
Franklin Ta <fta2012@gmail.com>
Frédéric Jacob <frederic.jacob.78@gmail.com>
Frédéric Wang <fred.wang@free.fr>
Fu Junwei <junwei.fu@intel.com>
Gabor Rapcsanyi <g.rapcsanyi@samsung.com>
Gaetano Mendola <mendola@gmail.com>
Gajendra N <gajendra.n@samsung.com>
Gajendra Singh <wxjg68@motorola.com>
Ganesh Borle <ganesh.borle@samsung.com>
Gao Chun <chun.gao@intel.com>
Gao Chun <gaochun.dev@gmail.com>
Gaurav Dhol <gaurav.dhol@einfochips.com>
Gautham Banasandra <gautham.bangalore@gmail.com>
George Adams <geoada@amazon.com>
George Joseph <kottackal.george@gmail.com>
George Liaskos <geo.liaskos@gmail.com>
Georgy Buranov <gburanov@gmail.com>
Gergely Nagy <ngg@ngg.hu>
Getulio Sánchez <valentin2507@gmail.com>
Gideon Pyzer <gjpyzer@gmail.com>
Giovanni Panaro <tsrwebgl@gmail.com>
Girish Kumar M <mck.giri@samsung.com>
Gitanshu Mehndiratta <g.mehndiratt@samsung.com>
Giuseppe Iuculano <giuseppe@iuculano.it>
Gnanasekar Somanathan <gnanasekar.s@samsung.com>
Gordana Cmiljanovic <gordana.cmiljanovic@imgtec.com>
Goutham Jagannatha <wrm364@motorola.com>
Graham Yoakum <gyoakum@skobalt.com>
Greg Visser <gregvis@gmail.com>
Gregory Davis <gpdavis.chromium@gmail.com>
Grzegorz Czajkowski <g.czajkowski@samsung.com>
Guangzhen Li <guangzhen.li@intel.com>
Gurpreet Kaur <k.gurpreet@samsung.com>
Gustav Tiger <gustav.tiger@sonymobile.com>
Gyuyoung Kim <gyuyoung.kim@navercorp.com>
Gzob Qq <gzobqq@gmail.com>
Habib Virji <habib.virji@samsung.com>
Haeun Kim <ggrace.kim93@gmail.com>
Haeun Kim <haeungun@gmail.com>
Haitao Feng <haitao.feng@intel.com>
Halley Zhao <halley.zhao@intel.com>
Halton Huo <halton.huo@gmail.com>
Halton Huo <halton.huo@intel.com>
Hans Hillen <hans.hillen@gmail.com>
Hao Li <hao.x.li@intel.com>
Haojian Wu <hokein.wu@gmail.com>
Hari Singh <hari.singh1@samsung.com>
Harpreet Singh Khurana <harpreet.sk@samsung.com>
Harshikesh Kumar <harshikeshnobug@gmail.com>
Hassan Salehe Matar <hassansalehe@gmail.com>
Hautio Kari <khautio@gmail.com>
Heejin R. Chung <heejin.r.chung@samsung.com>
Heeyoun Lee <heeyoun.lee@samsung.com>
Henrique Limas <henrique.ramos.limas@gmail.com>
Himanshu Joshi <h.joshi@samsung.com>
Holger Kraus <kraush@amazon.com>
Hong Zheng <hong.zheng@intel.com>
Hongbo Min <hongbo.min@intel.com>
Horia Olaru <horia.olaru@gmail.com>
Horia Olaru <olaru@adobe.com>
Hosung You <hosung.you@samsung.com>
Huapeng Li <huapengl@amazon.com>
Huayong Xu <huayong.xu@samsung.com>
Hugo Holgersson <hugo.holgersson@sonymobile.com>
Hui Wang <wanghui07050707@gmail.com>
Huiwon Jo <jhwon0415@gmail.com>
Huy Duong <huy.duongdinh@gmail.com>
Hwanseung Lee <hs1217.lee@gmail.com>
Hwanseung Lee <hs1217.lee@samsung.com>
Hyemi Shin <hyemi.sin@samsung.com>
HyeockJin Kim <kherootz@gmail.com>
Hyungchan Kim <inlinechan@gmail.com>
Hyungwook Lee <hyungwook.lee@navercorp.com>
Hyungwook Lee <withlhw@gmail.com>
Hyunjun Shin <hyunjun.shin2@navercorp.com>
Hyunjune Kim <hyunjune.kim@samsung.com>
Hyunki Baik <hyunki.baik@samsung.com>
Ian Cullinan <cullinan@amazon.com>
Ian Scott <ian.scott@arteris.com>
Ibrar Ahmed <ibrar.ahmad@gmail.com>
Ilia Demianenko <ilia.demianenko@gmail.com>
Ilia K <ki.stfu@gmail.com>
Ilya Konstantinov <ilya.konstantinov@gmail.com>
Imam Mohammad Bokhary <imam.bokhary@samsung.com>
Imranur Rahman <i.rahman@samsung.com>
Imranur Rahman <ir.shimul@gmail.com>
Ion Rosca <rosca@adobe.com>
Irmak Kavasoglu <irmakkavasoglu@gmail.com>
Isaac Murchie <murchieisaac@gmail.com>
Isaac Reilly <reillyi@amazon.com>
Ivan Naydonov <samogot@gmail.com>
Ivan Sham <ivansham@amazon.com>
Jack Bates <jack@nottheoilrig.com>
Jacob Clark <jacob.jh.clark@googlemail.com>
Jacob Mandelson <jacob@mandelson.org>
Jaehun Lim <ljaehun.lim@samsung.com>
Jaehyun Lee <j-hyun.lee@samsung.com>
Jaekyeom Kim <btapiz@gmail.com>
Jaemin Seo <jaemin86.seo@samsung.com>
Jaeseok Yoon <yjaeseok@gmail.com>
Jaewon Choi <jaewon.james.choi@gmail.com>
Jaeyong Bae <jdragon.bae@gmail.com>
Jaime Soriano Pastor <jsorianopastor@gmail.com>
Jake Helfert <jake@helfert.us>
Jake Hendy <me@jakehendy.com>
Jakob Weigert <jakob.j.w@googlemail.com>
Jakub Machacek <xtreit@gmail.com>
James Burton <jb@0.me.uk>
James Choi <jchoi42@pha.jhu.edu>
James Stanley <james@apphaus.co.uk>
James Vega <vega.james@gmail.com>
James Wei <james.wei@intel.com>
James Willcox <jwillcox@litl.com>
Jan Rucka <ruckajan10@gmail.com>
Jan Sauer <jan@jansauer.de>
Janwar Dinata <j.dinata@gmail.com>
Jared Shumway <jaredshumway94@gmail.com>
Jared Sohn <jared.sohn@gmail.com>
Jared Wein <weinjared@gmail.com>
Jari Karppanen <jkarp@amazon.com>
Jay Oster <jay@kodewerx.org>
Jay Soffian <jaysoffian@gmail.com>
Jeado Ko <haibane84@gmail.com>
Jeffrey C <jeffreyca16@gmail.com>
Jeongeun Kim <je_julie.kim@samsung.com>
Jeongmin Kim <kimwjdalsl@gmail.com>
Jeongwoo Park <skeksk91@gmail.com>
Jeremy Noring <jnoring@hirevue.com>
Jeremy Spiegel <jeremysspiegel@gmail.com>
Jeroen Van den Berghe <vandenberghe.jeroen@gmail.com>
Jerry Lin <wahahab11@gmail.com>
Jesper Storm Bache <jsbache@gmail.com>
Jesse Miller <jesse@jmiller.biz>
Jesus Sanchez-Palencia <jesus.sanchez-palencia.fernandez.fil@intel.com>
Jiadong Zhu <jiadong.zhu@linaro.org>
Jiajia Qin <jiajia.qin@intel.com>
Jiajie Hu <jiajie.hu@intel.com>
Jianjun Zhu <jianjun.zhu@intel.com>
Jianneng Zhong <muzuiget@gmail.com>
Jiawei Shao <jiawei.shao@intel.com>
Jie Chen <jie.a.chen@intel.com>
Jihan Chao <jihan@bluejeans.com>
Jihoon Chung <j.c@navercorp.com>
Jihoon Chung <jihoon@gmail.com>
Jihun Brent Kim <devgrapher@gmail.com>
Jihwan Marc Kim <bluewhale.marc@gmail.com>
Jin Yang <jin.a.yang@intel.com>
Jincheol Jo <jincheol.jo@navercorp.com>
Jinfeng Ma <majinfeng1@xiaomi.com>
Jing Zhao <zhaojing7@xiaomi.com>
Jinglong Zuo <zuojinglong@xiaomi.com>
Jingwei Liu <kingweiliu@gmail.com>
Jingyi Wei <wjywbs@gmail.com>
Jinho Bang <jinho.bang@samsung.com>
Jinsong Fan <fanjinsong@sogou-inc.com>
Jinwoo Song <jinwoo7.song@samsung.com>
Jinyoung Hur <hurims@gmail.com>
Jitendra Kumar Sahoo <jitendra.ks@samsung.com>
Joachim Bauch <jbauch@webrtc.org>
Joachim Bauch <mail@joachim-bauch.de>
Joanmarie Diggs <joanmarie.diggs@gmail.com>
Joe Knoll <joe.knoll@workday.com>
Joe Thomas <mhx348@motorola.com>
Joel Stanley <joel@jms.id.au>
Johannes Rudolph <johannes.rudolph@googlemail.com>
John Kleinschmidt <kleinschmidtorama@gmail.com>
John Yani <vanuan@gmail.com>
John Yoo <nearbyh13@gmail.com>
Johnson Lin <johnson.lin@intel.com>
Jonathan Frazer <listedegarde@gmail.com>
Jonathan Garbee <jonathan@garbee.me>
Jonathan Hacker <jhacker@arcanefour.com>
Jongdeok Kim <jongdeok.kim@navercorp.com>
Jongheon Kim <sapzape@gmail.com>
JongKwon Lee <jongkwon.lee@navercorp.com>
Jongsoo Lee <leejongsoo@gmail.com>
Joone Hur <joone.hur@intel.com>
Joonghun Park <pjh0718@gmail.com>
Jorge Villatoro <jorge@tomatocannon.com>
Joseph Gentle <josephg@gmail.com>
Joseph Lolak <joseph.lolak@samsung.com>
Josh Triplett <josh.triplett@intel.com>
Josh Triplett <josh@joshtriplett.org>
Joshua Lock <joshua.lock@intel.com>
Joshua Roesslein <jroesslein@gmail.com>
Josué Ratelle <jorat1346@gmail.com>
Josyula Venkat Narasimham <venkat.nj@samsung.com>
Juan Jose Lopez Jaimez <jj.lopezjaimez@gmail.com>
Juhui Lee <juhui24.lee@samsung.com>
Julien Brianceau <jbriance@cisco.com>
Julien Isorce <j.isorce@samsung.com>
Julien Racle <jracle@logitech.com>
Jun Fang <jun_fang@foxitsoftware.com>
Jun Jiang <jun.a.jiang@intel.com>
Junchao Han <junchao.han@intel.com>
Junghoon Lee <sjh836@gmail.com>
Junghyuk Yoo <wjdgurdl272@gmail.com>
JungJik Lee <jungjik.lee@samsung.com>
Jungkee Song <jungkee.song@samsung.com>
Junmin Zhu <junmin.zhu@intel.com>
Justin Okamoto <justmoto@amazon.com>
Justin Ribeiro <justin@justinribeiro.com>
Jüri Valdmann <juri.valdmann@qt.io>
Kai Jiang <jiangkai@gmail.com>
Kai Köhne <kai.koehne@qt.io>
Kai Uwe Broulik <kde@privat.broulik.de>
Kal Conley <kcconley@gmail.com>
Kalyan Kondapally <kalyan.kondapally@intel.com>
Kamil Jiwa <kamil.jiwa@gmail.com>
Kamil Rytarowski <krytarowski@gmail.com>
Kangil Han <kangil.han@samsung.com>
Kangyuan Shu <kangyuan.shu@intel.com>
Karan Thakkar <karanjthakkar@gmail.com>
Kartikey Bhatt <kartikey@amazon.com>
Kaspar Brand <googlecontrib@velox.ch>
Kaustubh Atrawalkar <kaustubh.a@samsung.com>
Kaustubh Atrawalkar <kaustubh.ra@gmail.com>
Ke He <ke.he@intel.com>
Keene Pan <keenepan@linpus.com>
Keita Yoshimoto <y073k3@gmail.com>
Keith Chen <keitchen@amazon.com>
Kenneth Rohde Christiansen <kenneth.r.christiansen@intel.com>
Kenneth Strickland <ken.strickland@gmail.com>
Kenneth Zhou <knthzh@gmail.com>
Keonho Kim <keonho07.kim@samsung.com>
Ketan Goyal <ketan.goyal@samsung.com>
Kevin Gibbons <bakkot@gmail.com>
Kevin Lee Helpingstine <sig11@reprehensible.net>
Kevin M. McCormick <mckev@amazon.com>
Khasim Syed Mohammed <khasim.mohammed@linaro.org>
Kihong Kwon <kihong.kwon@samsung.com>
Kihoon Ko <rhrlgns777@gmail.com>
Kihwang Kim <pwangkk@gmail.com>
Kim Christensen <kimworking@gmail.com>
Kimberly Hunter <kimberhu@amazon.com>
Kingshuk Jana <kingshuk.j@samsung.com>
Kirill Bobyrev <kirillbobyrev@gmail.com>
Kirill Ovchinnikov <kirill.ovchinn@gmail.com>
Klemen Forstnerič <klemen.forstneric@gmail.com>
Kodam Nagaraju <k2.nagaraju@samsung.com>
Konrad Dzwinel <kdzwinel@gmail.com>
Krishna Chaitanya <krish.botta@samsung.com>
Kristof Kosztyo <kkosztyo.u-szeged@partner.samsung.com>
Krzysztof Czech <k.czech@samsung.com>
Krzysztof Wolanski <k.wolanski@samsung.com>
Kui Tan <tk1061178@gmail.com>
Kunal Thakar <kunalt@gmail.com>
Kushal Pisavadia <kushi.p@gmail.com>
Kwangho Shin <k_h.shin@samsung.com>
Kyle Nahrgang <kpn24@drexel.edu>
Kyle Plumadore <kyle.plumadore@amd.com>
Kyounga Ra <kyounga.ra@gmail.com>
Kyoungdeok Kwon <kkd927@gmail.com>
Kyung Yeol Kim <chitacan@gmail.com>
Kyungtae Kim <ktf.kim@samsung.com>
Kyungyoung Heo <bbvch13531@gmail.com>
Lalit Chandivade <lalit.chandivade@einfochips.com>
Laszlo Gombos <l.gombos@samsung.com>
Laszlo Radanyi <bekkra@gmail.com>
Lauren Yeun Kim <lauren.yeun.kim@gmail.com>
Lauri Oherd <lauri.oherd@gmail.com>
Lavar Askew <open.hyperion@gmail.com>
Legend Lee <guanxian.li@intel.com>
Leith Bade <leith@leithalweapon.geek.nz>
Lenny Khazan <lenny.khazan@gmail.com>
Leo Wolf <jclw@ymail.com>
Leon Han <leon.han@intel.com>
Leung Wing Chung <lwchkg@gmail.com>
Li Yin <li.yin@intel.com>
Lidwine Genevet <lgenevet@cisco.com>
Lin Sun <lin.sun@intel.com>
Lingyun Cai <lingyun.cai@intel.com>
Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Lizhi Fan <lizhi.fan@samsung.com>
Loo Rong Jie <loorongjie@gmail.com>
Lorenzo Stoakes <lstoakes@gmail.com>
Lu Guanqun <guanqun.lu@gmail.com>
Luca Di Domenico <luca94dd@gmail.com>
Lucie Brozkova <lucinka.brozkova@gmail.com>
Luiz Von Dentz <luiz.von.dentz@intel.com>
Luka Dojcilovic <l.dojcilovic@gmail.com>
Luke Inman-Semerau <luke.semerau@gmail.com>
Luke Zarko <lukezarko@gmail.com>
Luoxi Pan <l.panpax@gmail.com>
Maarten Lankhorst <m.b.lankhorst@gmail.com>
Magnus Danielsson <fuzzac@gmail.com>
Mahesh Kulkarni <mahesh.kk@samsung.com>
Mahesh Machavolu <mahesh.ma@samsung.com>
Maksim Kolesin <mkolesin@gmail.com>
Maksim Sisov <maksim.sisov@intel.com>
Malcolm Wang <malcolm.2.wang@gmail.com>
Mallikarjuna Rao V <vm.arjun@samsung.com>
Manish Chhajer <chhajer.m@samsung.com>
Manish Jethani <m.jethani@eyeo.com>
Manojkumar Bhosale <manojkumar.bhosale@imgtec.com>
Manuel Braun <thembrown@gmail.com>
Mao Yujie <maojie0924@gmail.com>
Mao Yujie <yujie.mao@intel.com>
Marc des Garets <marc.desgarets@googlemail.com>
Marcin Wiacek <marcin@mwiacek.com>
Marco Rodrigues <gothicx@gmail.com>
Mario Pistrich <m.pistrich@gmail.com>
Mario Sanchez Prada <mario.prada@samsung.com>
Mariusz Mlynski <marius.mlynski@gmail.com>
Mark Hahnenberg <mhahnenb@andrew.cmu.edu>
Mark Seaborn <mrs@mythic-beasts.com>
Martijn Croonen <martijn@martijnc.be>
Martin Bednorz <m.s.bednorz@gmail.com>
Martin Rogalla <martin@martinrogalla.com>
Martina Kollarova <martina.kollarova@intel.com>
Masahiro Yado <yado.masa@gmail.com>
Masaru Nishida <msr.i386@gmail.com>
Matej Knopp <matej.knopp@gmail.com>
Matheus Bratfisch <matheusbrat@gmail.com>
Mathias Bynens <mathias@qiwi.be>
Mathieu Meisser <mmeisser@logitech.com>
Matt Arpidone <mma.public@gmail.com>
Matt Strum <mstrum@amazon.com>
Matt Zeunert <matt@mostlystatic.com>
Matthew Bauer <mjbauer95@gmail.com>
Matthew Demarest <demarem@amazon.com>
Matthew Robertson <matthewrobertson03@gmail.com>
Matthew Turk <matthewturk@gmail.com>
Matthew Willis <appamatto@gmail.com>
Matthias Reitinger <reimarvin@gmail.com>
Matthieu Rigolot <matthieu.rigolot@gmail.com>
Max Perepelitsyn <pph34r@gmail.com>
Max Vujovic <mvujovic@adobe.com>
Mayank Gupta <mayank.g1@samsung.com>
Mayur Kankanwadi <mayurk.vk@samsung.com>
Md Abdullah Al Alamin <a.alamin.cse@gmail.com>
Md. Hasanur Rashid <hasanur.r@samsung.com>
Md Jobed Hossain <jrony15@gmail.com>
Md Sami Uddin <md.sami@samsung.com>
Michael Cirone <mikecirone@gmail.com>
Michael Gilbert <floppymaster@gmail.com>
Michael Lopez <lopes92290@gmail.com>
Michael Morrison <codebythepound@gmail.com>
Michael Müller <michael@fds-team.de>
Michael Schechter <mike.schechter@gmail.com>
Michaël Zasso <mic.besace@gmail.com>
Michael Zugelder <michael@zugelder.org>
Michel Promonet <michel.promonet.1@gmail.com>
Mihai Maerean <mmaerean@adobe.com>
Mihai Tica <mihai.o.tica@gmail.com>
Mihai Tica <mitica@adobe.com>
Mike Pennisi <mike@mikepennisi.com>
Mike Tilburg <mtilburg@adobe.com>
Mikhail Pozdnyakov <mikhail.pozdnyakov@intel.com>
Milko Leporis <milko.leporis@imgtec.com>
Milton Chiang <milton.chiang@mediatek.com>
Milutin Smiljanic <msmiljanic.gm@gmail.com>
Minggang Wang <minggang.wang@intel.com>
Mingmin Xie <melvinxie@gmail.com>
Minjeong Lee <apenr1234@gmail.com>
Minseok Koo <kei98301@gmail.com>
Minsoo Max Koo <msu.koo@samsung.com>
Miran Karic <miran.karic@imgtec.com>
Mirela Budaes <mbudaes@adobe.com>
Mirela Budaes <mbudaes@gmail.com>
Miyoung Shin <myid.shin@navercorp.com>
Mohamed I. Hammad <ibraaaa@gmail.com>
Mohamed Mansour <m0.interactive@gmail.com>
Mohammad Azam <m.azam@samsung.com>
Mohammed Wajahat Ali Siddiqui <wajahat.s@samsung.com>
Mohan Reddy <mohan.reddy@samsung.com>
Mohit Bhalla <bhallam@amazon.com>
Momoko Hattori <momohatt10@gmail.com>
Mostafa Sedaghat joo <mostafa.sedaghat@gmail.com>
Mrunal Kapade <mrunal.kapade@intel.com>
Myeongjin Cho <myeongjin.cho@navercorp.com>
Myles C. Maxfield <mymax@amazon.com>
Myung-jong Kim <mjkim610@gmail.com>
Nagarajan Narayanan <nagarajan.n@samsung.com>
Nagarjuna Atluri <nagarjuna.a@samsung.com>
Naiem Shaik <naiem.shaik@gmail.com>
Naoki Takano <takano.naoki@gmail.com>
Naveen Bobbili <naveenbobbili@motorola.com>
Naveen Bobbili <qghc36@motorola.com>
Naveen Kumar Devaraj <devarajn@amazon.com>
Naveen Kumar S G <naveensg@samsung.com>
Nayan Kumar K <qtc746@motorola.com>
Neal Gompa <ngompa13@gmail.com>
Ned Williamson <nedwilliamson@gmail.com>
Nedeljko Babic <nedeljko.babic@imgtec.com>
Nikhil Bansal <n.bansal@samsung.com>
Nikhil Sahni <nikhil.sahni@samsung.com>
Nikita Ofitserov <himikof@gmail.com>
Niklas Hambüchen <mail@nh2.me>
Niklas Schulze <me@jns.io>
Nikola Kovacs <nikola.kovacs@gmail.com>
Nils Schneider <nils.schneider@gmail.com>
Nils Schneider <nils@nilsschneider.net>
Ningxin Hu <ningxin.hu@intel.com>
Nitish Mehrotra <nitish.m@samsung.com>
Noj Vek <nojvek@gmail.com>
Nolan Cao <nolan.robin.cao@gmail.com>
Oleksii Kadurin <ovkadurin@gmail.com>
Oliver Dunk <oliver@oliverdunk.com>
Olli Raula (Old name Olli Syrjälä) <olli.raula@intel.com>
Omar Sandoval <osandov@osandov.com>
Pan Deng <pan.deng@intel.com>
Parag Radke <nrqv63@motorola.com>
Paritosh Kumar <paritosh.in@samsung.com>
Patrasciuc Sorin Cristian <cristian.patrasciuc@gmail.com>
Patrick Chan <chanpatorikku@gmail.com>
Patrick Kettner <patrickkettner@gmail.com>
Patrick Riordan <patrickriordan177@gmail.com>
Patrick Stein <patrickwonders@gmail.com>
Patrik Ackland <patrikackland@gmail.com>
Paul Adolph <padolph@netflix.com>
Paul Kehrer <paul.l.kehrer@gmail.com>
Paul Lind <paul.lind@imgtec.com>
Paul Nettleship <pnettleship@gmail.com>
Paul Robinson <paulrobinson85@googlemail.com>
Paul Roskell <blurrech@gmail.com>
Paul Sapunaru <paul.sapunaru@intel.com>
Paul Wicks <pwicks86@gmail.com>
Pavan Kumar Emani <pavan.e@samsung.com>
Pavel Golikov <paullo612@ya.ru>
Pavel Ivanov <paivanof@gmail.com>
Pawel Forysiuk <p.forysiuk@samsung.com>
Paweł Hajdan jr <phajdan.jr@gmail.com>
Payal Pandey <payal.pandey@samsung.com>
Peng Hu <penghu@tencent.com>
Peng Jiang <leiyi.jp@gmail.com>
Peng Xinchao <pxinchao@gmail.com>
Peter Bright <drpizza@quiscalusmexicanus.org>
Peter Brophy <pbrophy@adobe.com>
Peter Collingbourne <peter@pcc.me.uk>
Peter Gal <pgal.u-szeged@partner.samsung.com>
Peter Griffin <peter.griffin@linaro.org>
Peter Molnar <pmolnar.u-szeged@partner.samsung.com>
Peter Snyder <snyderp@gmail.com>
Peter Wong <peter.wm.wong@gmail.com>
Philip Hanson <philip.hanson@intel.com>
Philipp Hancke <fippo@andyet.net>
Philipp Hancke <philipp.hancke@googlemail.com>
Philippe Beauchamp <philippe.beauchamp@gmail.com>
Philippe Beaudoin <philippe.beaudoin@gmail.com>
PhistucK <phistuck@gmail.com>
Pierre Neter <pierreneter@gmail.com>
Pierre-Antoine LaFayette <pierre.lafayette@gmail.com>
Po-Chun Chang <pochang0403@gmail.com>
Pramod Begur Srinath <pramod.bs@samsung.com>
Pranay Kumar <pranay.kumar@samsung.com>
Pranjal Jumde <pranjal@brave.com>
Prashant Hiremath <prashhir@cisco.com>
Prashant Nevase <prashant.n@samsung.com>
Prashant Patil <prashant.patil@imgtec.com>
Praveen Akkiraju <praveen.anp@samsung.com>
Preeti Nayak <preeti.nayak@samsung.com>
Pritam Nikam <pritam.nikam@samsung.com>
Puttaraju R <puttaraju.r@samsung.com>
Qi Yang <qi1988.yang@samsung.com>
Qiankun Miao <qiankun.miao@intel.com>
Qing Zhang <qing.zhang@intel.com>
Qingmei Li <qingmei.li@vivo.com>
Radu Stavila <stavila@adobe.com>
Radu Velea <radu.velea@intel.com>
Rafael Antognolli <rafael.antognolli@intel.com>
Raghavendra Ghatage <r.ghatage@samsung.com>
Raghu Ram Nagaraj <r.nagaraj@samsung.com>
Rahul Gupta <rahul.g@samsung.com>
Rajneesh Rana <rajneesh.r@samsung.com>
Raman Tenneti <raman.tenneti@gmail.com>
Ramkumar Gokarnesan <ramkumar.gokarnesan@gmail.com>
Ramkumar Ramachandra <artagnon@gmail.com>
Ramya Vadlamudi <ramya.v@samsung.com>
Randy Posynick <randy.posynick@gmail.com>
Raphael Kubo da Costa <raphael.kubo.da.costa@intel.com>
Raul Tambre <raul@tambre.ee>
Raveendra Karu <r.karu@samsung.com>
Ravi Nanjundappa <nravi.n@samsung.com>
Ravi Phaneendra Kasibhatla <r.kasibhatla@samsung.com>
Ravi Phaneendra Kasibhatla <ravi.kasibhatla@motorola.com>
Raviraj Sitaram <raviraj.p.sitaram@intel.com>
Réda Housni Alaoui <alaoui.rda@gmail.com>
Refael Ackermann <refack@gmail.com>
Renata Hodovan <rhodovan.u-szeged@partner.samsung.com>
Rene Bolldorf <rb@radix.io>
Rene Ladan <r.c.ladan@gmail.com>
Richard Baranyi <lordprotector@gmail.com>
Richard Li <richard.li@intel.com>
Rijubrata Bhaumik <rijubrata.bhaumik@intel.com>
Riku Voipio <riku.voipio@linaro.org>
Rob Buis <rob.buis@samsung.com>
Rob Wu <rob@robwu.nl>
Robert Bear Travis <bear.travis@gmail.com>
Robert Bear Travis <betravis@adobe.com>
Robert Bradford <robert.bradford@intel.com>
Robert Goldberg <goldberg@adobe.com>
Robert Hogan <robhogan@gmail.com>
Robert Nagy <robert.nagy@gmail.com>
Robert Sesek <rsesek@bluestatic.org>
Roland Takacs <rtakacs.u-szeged@partner.samsung.com>
Romain Pokrzywka <romain.pokrzywka@gmail.com>
Rosen Dash <nqk836@motorola.com>
Rosen Dash <rosen.dash@gmail.com>
Ross Kirsling <rkirsling@gmail.com>
ruben <chromium@hybridsource.org>
Ruben Bridgewater <ruben@bridgewater.de>
Ruben Terrazas <rubentopo@gmail.com>
Rufus Hamade <rufus.hamade@imgtec.com>
Ruiyi Luo <luoruiyi2008@gmail.com>
Ryan Ackley <ryanackley@gmail.com>
Ryan Norton <rnorton10@gmail.com>
Ryan Sleevi <ryan-chromium-dev@sleevi.com>
Ryan Yoakum <ryoakum@skobalt.com>
Ryuan Choi <ryuan.choi@samsung.com>
Saikrishna Arcot <saiarcot895@gmail.com>
Sajal Khandelwal <skhandelwa22@bloomberg.net>
Salvatore Iovene <salvatore.iovene@intel.com>
Sam Larison <qufighter@gmail.com>
Sam McDonald <sam@sammcd.com>
Samuel Attard <samuel.r.attard@gmail.com>
Sanggi Hong <sanggi.hong11@gmail.com>
Sanghee Lee <sanghee.lee1992@gmail.com>
Sanghyun Park <sh919.park@samsung.com>
Sanghyup Lee <sh53.lee@samsung.com>
Sangjoon Je <htamop@gmail.com>
Sangseok Jang <sangseok.jang@navercorp.com>
Sangwoo Ko <sangwoo.ko@navercorp.com>
Sangwoo Ko <sangwoo108@gmail.com>
Sanjoy Pal <ncj674@motorola.com>
Sanjoy Pal <sanjoy.pal@samsung.com>
Sanne Wouda <sanne.wouda@gmail.com>
Santosh Mahto <samahto@cisco.com>
Sarath Singapati <s.singapati@gmail.com>
Sarath Singapati <s.singapati@samsung.com>
Sarath Singapati <sarath.singapati@huawei.com>
Saravanan KR <sramajay@cisco.com>
Sathish Kuppuswamy <sathish.kuppuswamy@intel.com>
Satoshi Matsuzaki <satoshi.matsuzaki@gmail.com>
Satyajit Sahu <satyajit.sahu@amd.com>
Sayan Nayak <sayan.nayak@samsung.com>
Scott D Phillips <scott.d.phillips@intel.com>
Sean Bryant <sean@cyberwang.net>
Sean DuBois <seaduboi@amazon.com>
Sebastian Amend <sebastian.amend@googlemail.com>
Sebastian Krzyszkowiak <dos@dosowisko.net>
Seo Sanghyeon <sanxiyn@gmail.com>
Seokju Kwon <seokju.kwon@gmail.com>
SeongTae Jeong <ferendevelop.gl@gmail.com>
Sergey Kipet <sergey.kipet@gmail.com>
Sergey Putilin <p.sergey@samsung.com>
Sergey Shekyan <shekyan@gmail.com>
Sergio Carlos Morales Angeles <carloschilazo@gmail.com>
Sergiy Belozorov <rryk.ua@gmail.com>
Seshadri Mahalingam <seshadri.mahalingam@gmail.com>
Seungkyu Lee <zx6658@gmail.com>
Sevan Janiyan <venture37@geeklan.co.uk>
Shahriar Rostami <shahriar.rostami@gmail.com>
Shail Singhal <shail.s@samsung.com>
Shane Hansen <shanemhansen@gmail.com>
ShankarGanesh K <blr.bmlab@gmail.com>
Shanmuga Pandi M <shanmuga.m@samsung.com>
Shaobo Yan <shaobo.yan@intel.com>
Shashi Kumar <sk.kumar@samsung.com>
Shawn Anastasio <shawnanastasio@gmail.com>
Shelley Vohr <shelley.vohr@gmail.com>
Shen Yu <shenyu.tcv@gmail.com>
Sherry Mou <wenjinm@amazon.com>
Shez Baig <sbaig1@bloomberg.net>
Shigeki Ohtsu <shigeki.ohtsu@gmail.com>
Shiliu Wang <aofdwsl@gmail.com>
Shiliu Wang <shiliu.wang@intel.com>
Shilpa Shri <shilpa.shri@samsung.com>
Shirish S <shirish.s@amd.com>
Shiva Kumar <shiva.k1@samsung.com>
Shivakumar JM <shiva.jm@samsung.com>
Shouqun Liu <liushouqun@xiaomi.com>
Shouqun Liu <shouqun.liu@intel.com>
Shreeram Kushwaha <shreeram.k@samsung.com>
Shreyas Gopal <shreyas.g@samsung.com>
Shreyas VA <v.a.shreyas@gmail.com>
Shubham Agrawal <shubag@amazon.com>
Siba Samal <siba.samal@samsung.com>
Siddharth Bagai <b.siddharth@samsung.com>
Siddharth Shankar <funkysidd@gmail.com>
Simon Arlott <simon.arlott@gmail.com>
Simon La Macchia <smacchia@amazon.com>
Siva Kumar Gunturi <siva.gunturi@samsung.com>
Sohan Jyoti Ghosh <sohan.jyoti@huawei.com>
Sohan Jyoti Ghosh <sohan.jyoti@samsung.com>
Song YeWen <ffmpeg@gmail.com>
Sooho Park <sooho1000@gmail.com>
Soojung Choi <crystal2840@gmail.com>
Soorya R <soorya.r@samsung.com>
Soren Dreijer <dreijerbit@gmail.com>
Sreerenj Balachandran <sreerenj.balachandran@intel.com>
Srirama Chandra Sekhar Mogali <srirama.m@samsung.com>
Staphany Park <stapark008@gmail.com>
Stephen Searles <stephen.searles@gmail.com>
Steve Sanders <steve@zanderz.com>
Steven Pennington <spenn@engr.uvic.ca>
Steven Roussey <sroussey@gmail.com>
Subrahmanya Praveen Munukutla <sataya.m@samsung.com>
Suchit Agrawal <a.suchit@samsung.com>
Sudarsana Babu Nagineni <sudarsana.nagineni@intel.com>
Sudarshan Parthasarathy <sudarshan.p@samsung.com>
Sujae Jo <sujae33.jo@gmail.com>
Sujith S S <sujiths.s@samsung.com>
Sunchang Li <johnstonli@tencent.com>
Suneel Kota <suneel.kota@samsung.com>
Sungguk Lim <limasdf@gmail.com>
Sungmann Cho <sungmann.cho@gmail.com>
Sungmann Cho <sungmann.cho@navercorp.com>
Sunil Ratnu <sunil.ratnu@samsung.com>
Sunitha Srivatsa <srivats@amazon.com>
Suvanjan Mukherjee <suvanjanmukherjee@gmail.com>
Suyambulingam R M <suyambu.rm@samsung.com>
Suyash Sengar <suyash.s@samsung.com>
Swarali Raut <swarali.sr@samsung.com>
Swati Jaiswal <swa.jaiswal@samsung.com>
Sylvain Zimmer <sylvinus@gmail.com>
Sylvestre Ledru <sylvestre.ledru@gmail.com>
Synthia Islam <synthia.is@samsung.com>
Szabolcs David <davidsz@inf.u-szeged.hu>
Szymon Piechowicz <szymonpiechowicz@o2.pl>
Taeheon Kim <skyrabbits1@gmail.com>
Taehoon Lee <taylor.hoon@gmail.com>
Takashi Fujita <tgfjt.mail@gmail.com>
Takeshi Kurosawa <taken.spc@gmail.com>
Tanay Chowdhury <tanay.c@samsung.com>
Tanvir Rizvi <tanvir.rizvi@samsung.com>
Tapu Kumar Ghose <ghose.tapu@gmail.com>
Taylor Price <trprice@gmail.com>
Ted Kim <neot0000@gmail.com>
Ted Vessenes <tedvessenes@gmail.com>
Teodora Novkovic <teodora.petrovic@gmail.com>
Thiago Farina <thiago.farina@gmail.com>
Thiago Marcos P. Santos <thiago.santos@intel.com>
Thomas Butter <tbutter@gmail.com>
Thomas Conti <tomc@amazon.com>
Thomas White <im.toms.inbox@gmail.com>
Tiago Vignatti <tiago.vignatti@intel.com>
Tibor Dusnoki <tibor.dusnoki.91@gmail.com>
Tim Ansell <mithro@mithis.com>
Tim Niederhausen <tim@rnc-ag.de>
Timo Gurr <timo.gurr@gmail.com>
Timo Reimann <ttr314@googlemail.com>
Timo Witte <timo.witte@gmail.com>
Ting Shao <ting.shao@intel.com>
Tom Callaway <tcallawa@redhat.com>
Tom Harwood <tfh@skip.org>
Tomas Popela <tomas.popela@gmail.com>
Torsten Kurbad <google@tk-webart.de>
Trent Willis <trentmwillis@gmail.com>
Trevor Perrin <unsafe@trevp.net>
Tripta Gupta <tripta.g@samsung.com>
U. Artie Eoff <ullysses.a.eoff@intel.com>
Umar Hansa <umar.hansa@gmail.com>
Upendra Gowda <upendrag.gowda@gmail.com>
Uzair Jaleel <uzair.jaleel@samsung.com>
Vadim Gorbachev <bmsdave@gmail.com>
Vaibhav Agrawal <vaibhav1.a@samsung.com>
Valentin Ilie <valentin.ilie@intel.com>
Vamshikrishna Yellenki <vamshi@motorola.com>
Vani Hegde <vani.hegde@samsung.com>
Varun Chowdhary Paturi <v.paturi@samsung.com>
Vartul Katiyar <vartul.k@samsung.com>
Vedran Šajatović <vedran.sajatovic@gmail.com>
Vernon Tang <vt@foilhead.net>
Viatcheslav Ostapenko <sl.ostapenko@samsung.com>
Victor Costan <costan@gmail.com>
Viet-Trung Luu <viettrungluu@gmail.com>
Vinay Anantharaman <vinaya@adobe.com>
Vipul Bhasin <vipul.bhasin@gmail.com>
Visa Putkinen <v.putkinen@partner.samsung.com>
Vishal Bhatnagar <vishal.b@samsung.com>
Vitaliy Kharin <kvserr@gmail.com>
Vivek Galatage <vivek.vg@samsung.com>
Volker Sorge <volker.sorge@gmail.com>
Waihung Fu <fufranci@amazon.com>
Wanming Lin <wanming.lin@intel.com>
Wei Li <wei.c.li@intel.com>
WenSheng He <wensheng.he@samsung.com>
Wesley Lancel <wesleylancel@gmail.com>
Wei Wang <wei4.wang@intel.com>
Wesley Wigham <wwigham@gmail.com>
Will Hirsch <chromium@willhirsch.co.uk>
Will Shackleton <w.shackleton@gmail.com>
William Xie <william.xie@intel.com>
Xiang Long <xiang.long@intel.com>
Xiangze Zhang <xiangze.zhang@intel.com>
Xiaofeng Zhang <xiaofeng.zhang@intel.com>
Xiaolei Yu <dreifachstein@gmail.com>
Xiaoshu Zhang <xiaoshu@amazon.com>
Xiaoyin Liu <xiaoyin.l@outlook.com>
Xinchao He <hexinchao@gmail.com>
Xing Zhang <xzhang@adobe.com>
Xinghua Cao <xinghua.cao@intel.com>
Xu Samuel <samuel.xu@intel.com>
Xu Xing <xing.xu@intel.com>
Xuefei Ren <xrenishere@gmail.com>
Xueqing Huang <huangxueqing@xiaomi.com>
Xun Sun <xun.sun@intel.com>
Xunran Ding <xunran.ding@samsung.com>
Xunran Ding <dingxunran@gmail.com>
Yael Aharon <yael.aharon@intel.com>
Yan Wang <yan0422.wang@samsung.com>
Yang Gu <yang.gu@intel.com>
Yannic Bonenberger <yannic.bonenberger@gmail.com>
Yarin Kaul <yarin.kaul@gmail.com>
Yash Vempati <vempatiy@amazon.com>
Ye Liu <cbakgly@gmail.com>
Yeol Park <peary2@gmail.com>
Yeonwoo Jo <yeonwoo.jo.92@gmail.com>
Yi Shen <yi.shen@samsung.com>
Yi Sun <ratsunny@gmail.com>
Yichen Jiang <jiangyichen123@gmail.com>
Yifei Yu <yuyifei@xiaomi.com>
Yizhou Jiang <yizhou.jiang@intel.com>
Yoav Weiss <yoav@yoav.ws>
Yoav Zilberberg <yoav.zilberberg@gmail.com>
Yong Shin <sy3620@gmail.com>
Yong Wang <ccyongwang@tencent.com>
Yongha Lee <yongha78.lee@samsung.com>
Yongseok Choi <yongseok.choi@navercorp.com>
Yongsheng Zhu <yongsheng.zhu@intel.com>
Yoonjae Cho <yoonjae.cho92@gmail.com>
Yoshinori Sano <yoshinori.sano@gmail.com>
Youngho Seo <hazivoo@gmail.com>
Youngjin Choi <cyjin9.yc@gmail.com>
YoungKi Hong <simon.hong81@gmail.com>
Youngmin Yoo <youngmin.yoo@samsung.com>
Youngsoo Choi <kenshin.choi@samsung.com>
Youngsun Suh <zard17@gmail.com>
Yuhong Sha <yuhong.sha@samsung.com>
Yumikiyo Osanai <yumios.art@gmail.com>
Yunchao He <yunchao.he@intel.com>
Yupei Lin <yplam@yplam.com>
Yupei Wang <perryuwang@tencent.com>
Yura Yaroshevich <yura.yaroshevich@gmail.com>
Yuri Gorobets <yuri.gorobets@gmail.com>
Yuriy Taraday <yorik.sar@gmail.com>
Yuvanesh Natarajan <yuvanesh.n1@samsung.com>
Zeno Albisser <zeno.albisser@digia.com>
Zeqin Chen <talonchen@tencent.com>
Zhaoze Zhou <zhaoze.zhou@partner.samsung.com>
Zheda Chen <zheda.chen@intel.com>
Zheng Chuang <zhengchuangscu@gmail.com>
Zhengkun Li <zhengkli@amazon.com>
Zhenyu Liang <zhenyu.liang@intel.com>
Zhenyu Shan <zhenyu.shan@intel.com>
Zhifei Fang <facetothefate@gmail.com>
Zhuoyu Qian <zhuoyu.qian@samsung.com>
Ziran Sun <ziran.sun@samsung.com>
Zoltan Herczeg <zherczeg.u-szeged@partner.samsung.com>
Zoltan Kuscsik <zoltan.kuscsik@linaro.org>
Zsolt Borbely <zsborbely.u-szeged@partner.samsung.com>
方觉 (Fang Jue) <fangjue23303@gmail.com>
Rajesh Mahindra <rmahindra@uber.com>
Yuan-Pin Yu <yjames@uber.com>
Vinoth Chandar <vinoth@uber.com>
Zheng Xu <zxu@kobo.com>
Junsong Li <ljs.darkfish@gmail.com>

ACCESS CO., LTD. <*@access-company.com>
Akamai Inc. <*@akamai.com>
ARM Holdings <*@arm.com>
BlackBerry Limited <*@blackberry.com>
Bocoup <*@bocoup.com>
Canonical Limited <*@canonical.com>
Cloudflare, Inc. <*@cloudflare.com>
CloudMosa, Inc. <*@cloudmosa.com>
Code Aurora Forum <*@codeaurora.org>
Collabora Limited <*@collabora.com>
Comodo CA Limited
Cosium <*@cosium.com>
Duck Duck Go, Inc. <*@duckduckgo.com>
Endless Mobile, Inc. <*@endlessm.com>
Estimote, Inc. <*@estimote.com>
Facebook, Inc. <*@fb.com>
Facebook, Inc. <*@oculus.com>
Google Inc. <*@google.com>
Hewlett-Packard Development Company, L.P. <*@hp.com>
IBM Inc. <*@*.ibm.com>
IBM Inc. <*@ibm.com>
Igalia S.L. <*@igalia.com>
Imagination Technologies Limited <*@imagination.corp-partner.google.com>
Impossible Dreams Network <*@impossibledreams.net>
Intel Corporation <*@intel.com>
LG Electronics, Inc. <*@lge.com>
Loongson Technology Corporation Limited. <*@loongson.cn>
Macadamian <*@macadamian.com>
Mediatek <*@mediatek.com>
Microsoft <*@microsoft.com>
MIPS Technologies, Inc. <*@mips.com>
Mozilla Corporation <*@mozilla.com>
Neverware Inc. <*@neverware.com>
NIKE, Inc. <*@nike.com>
NVIDIA Corporation <*@nvidia.com>
Opera Software ASA <*@opera.com>
Optical Tone Ltd <*@opticaltone.com>
Pengutronix e.K. <*@pengutronix.de>
Rakuten Kobo Inc. <*@kobo.com>
Rakuten Kobo Inc. <*@rakuten.com>
Seznam.cz, a.s. <*@firma.seznam.cz>
Slack Technologies Inc. <*@slack-corp.com>
Spotify AB <*@spotify.com>
Tableau Software <*@tableau.com>
TeamSpeak Systems GmbH <*@teamspeak.com>
The Chromium Authors <*@chromium.org>
The MathWorks, Inc. <binod.pant@mathworks.com>
Torchmobile Inc.
Upwork <*@cloud.upwork.com>
Venture 3 Systems LLC <*@venture3systems.com>
Vewd Software AS <*@vewd.com>
Vivaldi Technologies AS <*@vivaldi.com>
Yandex LLC <*@yandex-team.ru>
Make Positive Provar Limited <*@provartesting.com>
Jiaxun Wei <leuisken@gmail.com>
