tree f69d13d88559e3286e402af81d7edd74a3ef2785
parent 0cadf40f4c3613c0170120f4b902cb153338db15
author Dmitri Shuralyov <dmitshur@golang.org> 1563308989 -0400
committer Dmitri Shuralyov <dmitshur@golang.org> 1563368272 +0000

CONTRIBUTORS: first round of updates for Go 1.13

This update has been automatically generated using the updatecontrib
command:

	cd gotip
	go run golang.org/x/build/cmd/updatecontrib

With minor manual changes to canonicalize letter case for a few names.

Actions taken (relative to CONTRIBUTORS at origin/master):

	Added Ahsun Ahmed <ahmed.ahsun@gmail.com>
	Added Al Cutter <al@google.com>
	Added Alex Tokarev <aleksator@gmail.com>
	Added Alexander Lourier <aml@rulezz.ru>
	Added Alexander Rakoczy <alex@golang.org>
	Added Andrei Matei <andrei@cockroachlabs.com>
	Added Andrei Vagin <avagin@google.com>
	Added Andrew Z Allen <me@andrewzallen.com>
	Added Aofei Sheng <aofei@aofeisheng.com>
	Added Arash Bina <arash@arash.io>
	Added Benjamin Peterson <benjamin@python.org>
	Added Bjørn Erik Pedersen <bjorn.erik.pedersen@gmail.com>
	Added Brandon Ryan <bjryan19@gmail.com>
	Added Bryan Heden <b.heden@gmail.com>
	Added Carlos Eduardo <me@carlosedp.com>
	Added Carrie Bynon <cbynon@gmail.com>
	Added Chris Marchesi <chrism@vancluevertech.com>
	Added Colin Arnott <colin@urandom.co.uk>
	Added Daniel Cormier <danielc@knowbe4.com>
	Added Daniel Langner <s8572327@gmail.com>
	Added Daniel Lublin <daniel@lublin.se>
	Added Darren Grant <darren.e.grant@gmail.com>
	Added Derek Phan <derekphan94@gmail.com>
	Added Dmitri Goutnik <dgoutnik@gmail.com>
	Added Dmitry Mottl <dmitry.mottl@gmail.com>
	Added Eli Bendersky <eliben@google.com>
	Added Evan Digby <evandigby@gmail.com>
	Added Fedor Korotkiy <dartslon@gmail.com>
	Added Felix Bünemann <Felix.Buenemann@gmail.com>
	Added Francesco Renzi <rentziass@gmail.com>
	Added Gabriel Guzman <gabe.guzman@gmail.com>
	Added Gabriel Nelle <tehsphinx@web.de>
	Added Gernot Vormayr <gvormayr@gmail.com>
	Added GitHub User ZZMarquis (7624583) <zhonglingjian3821@163.com>
	Added GitHub User alkesh26 (1019076) <alkesh26@gmail.com>
	Added GitHub User bakape (7851952) <bakape@gmail.com>
	Added GitHub User frennkie (6499251) <mail@rhab.de>
	Added GitHub User hengwu0 (41297446) <41297446+hengwu0@users.noreply.github.com>
	Added GitHub User kazyshr (30496953) <kazyshr0301@gmail.com>
	Added GitHub User linguohua (3434367) <lghchinaidea@gmail.com>
	Added GitHub User micnncim (21333876) <micnncim@gmail.com>
	Added Gordon Tyler <gordon@doxxx.net>
	Added Greg Thelen <gthelen@google.com>
	Added Haosdent Huang <haosdent@gmail.com>
	Added Hasan Ozgan <hasan@ozgan.net>
	Added Henry Wong <liushuai.wang@elastic.co>
	Added Horst Rutter <hhrutter@gmail.com>
	Added Ivan Osadchiy <ivan.osadchii@gmail.com>
	Added JT Olio <hello@jtolio.com>
	Added Jacob Blain Christen <dweomer5@gmail.com>
	Added Jacob Walker <jacobwalker0814@gmail.com>
	Added James Nugent <james@jen20.com>
	Added Jannis Andrija Schnitzer <jannis@schnitzer.im>
	Added Jean-François Bustarret <jf@bustarret.com>
	Added Jeremy Jay <jeremy@pbnjay.com>
	Added Jeroen Simonetti <jeroen@simonetti.nl>
	Added Jingnan Si <jingnan.si@gmail.com>
	Added Jinkun Zhang <franksnolf@gmail.com>
	Added John Moore <johnkenneth.moore@gmail.com>
	Added John Weldon <johnweldon4@gmail.com>
	Added Jonathon Lacher <jonathon.lacher@gmail.com>
	Added Jordan Liggitt <liggitt@google.com>
	Added Joshua M. Clulow <josh.clulow@joyent.com>
	Added Juraj Sukop <sukop@users.noreply.github.com>
	Added Justin Li <git@justinli.net>
	Added Kai Dong <dokia2357@gmail.com>
	Added Kenichi Tsunokawa <kenichi.tsunokawa@gmail.com>
	Added Kenta Mori <zoncoen@gmail.com>
	Added Ketan Parmar <ketanbparmar@gmail.com>
	Added Kirill Motkov <Motkov.Kirill@gmail.com>
	Added Kshitij Saraogi <kshitijsaraogi@gmail.com>
	Added Leonardo Comelli <leonardo.comelli@gmail.com>
	Added Lorenz Nickel <mail@lorenznickel.de>
	Added Luka Zitnik <luka.zitnik@gmail.com>
	Added Luke Champine <luke.champine@gmail.com>
	Added Madhu Rajanna <madhupr007@gmail.com>
	Added Marat Khabibullin <marat.khabibullin@jetbrains.com>
	Added Mark Villacampa <m@markvillacampa.com>
	Added Max Semenik <maxsem.wiki@gmail.com>
	Added Maxim Eryomenko <moeryomenko@gmail.com>
	Added Michael Cook <code@mdcook.net>
	Added Michael Vogt <mvo@ubuntu.com>
	Added Mickael KERJEAN <mickael.kerjean@gmail.com>
	Added Mickey Reiss <mickeyreiss@gmail.com>
	Added Mihai Moldovan <ionic@ionic.de>
	Added Mirko Hansen <baaazen@gmail.com>
	Added Muir Manders <muir@mnd.rs>
	Added Mykhailo Lesyk <mikhail@lesyk.org>
	Added Nick Anthony <Liberatys@outlook.com>
	Added Nikita Kryuchkov <nkryuchkov10@gmail.com>
	Added Nir Soffer <nirsof@gmail.com>
	Added Norman B. Lancaster <qbradq@gmail.com>
	Added Patrick Barker <barkerp@vmware.com>
	Added Patrik Lundin <patrik@sigterm.se>
	Added Petr Jediný <petr.jediny@gmail.com>
	Added Robert Ayrapetyan <robert.ayrapetyan@gmail.com>
	Added Robert van Gent <rvangent@google.com>
	Added Rohan Verma <rohanverma2004@gmail.com>
	Added Romain Baugue <romain.baugue@elwinar.com>
	Added Sad Pencil <qh06@qq.com>
	Added Segev Finer <segev208@gmail.com>
	Added Sergey Dobrodey <sergey.dobrodey@synesis.ru>
	Added Sergey Yanykin <syanykin@ozon.ru>
	Added Shawn Elliott <selliott@microsoft.com>
	Added Shengjing Zhu <zsj950618@gmail.com>
	Added Shubham Sharma <shubham.sha12@gmail.com>
	Added Stephan Zuercher <zuercher@gmail.com>
	Added Steve Mynott <steve.mynott@gmail.com>
	Added Tai Le <letientai299@gmail.com>
	Added Todd Kulesza <tkulesza@google.com>
	Added Tom Anthony <git@tomanthony.co.uk>
	Added Tooru Takahashi <tooru.takahashi134@gmail.com>
	Added Udalov Max <re.udalov@gmail.com>
	Added Valentin Vidic <vvidic@valentin-vidic.from.hr>
	Added Vivek Sekhar <vsekhar@google.com>
	Added WEI Xikai <xykwei@gmail.com>
	Added Wenlei (Frank) He <wlhe@google.com>
	Added Wenzel Lowe <lowewenzel@gmail.com>
	Added Yang Tian <linuxty@gmail.com>
	Added Yasser Abdolmaleki <yasser@yasser.ca>
	Added Zach Jones <zachj1@gmail.com>
	Added adarsh ravichandran <adarshravichandran91@gmail.com>
	Added berkant ipek <41230766+0xbkt@users.noreply.github.com>
	Added karthik nayak <karthik.188@gmail.com>
	Added marius a. eriksen <marius@grailbio.com>
	Added Максадбек Ахмедов <a.maksadbek@gmail.com>
	Used GitHub User ZZMarquis (7624583) form for ZZMarquis <zhonglingjian3821@163.com> https://github.com/golang/go/commit/b00ef3b865 [go]
	Used GitHub User alkesh26 (1019076) form for alkesh26 <alkesh26@gmail.com> https://github.com/golang/go/commit/c7f69a2897 [go]
	Used GitHub User bakape (7851952) form for bakape <bakape@gmail.com> https://github.com/golang/go/commit/27e444d5e6 [go]
	Used GitHub User frennkie (6499251) form for frennkie <mail@rhab.de> https://github.com/golang/go/commit/ee46250e06 [go]
	Used GitHub User hengwu0 (41297446) form for hengwu0 <41297446+hengwu0@users.noreply.github.com> https://github.com/golang/go/commit/95d4e6158b [go]
	Used GitHub User kazyshr (30496953) form for kazyshr <kazyshr0301@gmail.com> https://github.com/golang/tools/commit/0fdf0c73 [tools]
	Used GitHub User linguohua (3434367) form for linguohua <lghchinaidea@gmail.com> https://github.com/golang/tools/commit/97de5656 [tools]
	Used GitHub User micnncim (21333876) form for micnncim <micnncim@gmail.com> https://github.com/golang/tools/commit/15d5d381 [tools]
	Used GitHub name "Akhil Indurti" for smasher164 <aindurti@gmail.com> https://github.com/golang/go/commit/5ca44dc403 [build go]
	Used GitHub name "Carlos Eduardo" for CarlosEDP <me@carlosedp.com> https://github.com/golang/net/commit/018c4d4 [net]
	Used GitHub name "Ivan Markin" for nogoegst <nogoegst@users.noreply.github.com> https://github.com/golang/go/commit/a1addf15df [go]
	Used GitHub name "Jean-François Bustarret" for jfbus <jf@bustarret.com> https://github.com/golang/go/commit/825ff1e317 [go]
	Used GitHub name "Jinkun Zhang" for smileeye <franksnolf@gmail.com> https://github.com/golang/go/commit/607493bed6 [go]
	Used GitHub name "John Moore" for guitarbum722 <johnkenneth.moore@gmail.com> https://github.com/golang/go/commit/44c9354c5a [go]
	Used GitHub name "Keiji Yoshida" for yosssi <yoshida.keiji.84@gmail.com> https://github.com/golang/lint/commit/ac6833c [lint]
	Used GitHub name "Kenta Mori" for zoncoen <zoncoen@gmail.com> https://github.com/golang/net/commit/fe579d4 [net]
	Used GitHub name "Kirill Motkov" for Motkov.Kirill <Motkov.Kirill@gmail.com> https://github.com/golang/go/commit/0ff0df8be3 [go]
	Used GitHub name "Luke Champine" for lukechampine <luke.champine@gmail.com> https://github.com/golang/go/commit/9d40fadb1c [crypto go]
	Used GitHub name "Michalis Kargakis" for kargakis <mkargaki@redhat.com> https://github.com/golang/go/commit/e243d242d7 [go]
	Used GitHub name "Nick Anthony" for Liberatys <Liberatys@outlook.com> https://github.com/golang/go/commit/62ddf7d0c5 [go]
	Used GitHub name "Robert Ayrapetyan" for rayrapetyan <robert.ayrapetyan@gmail.com> https://github.com/golang/sys/commit/bf70e46 [sys]
	Used GitHub name "Robin Eklind" for mewmew <rnd0x00@gmail.com> https://github.com/golang/go/commit/b8620afb8d [blog go proposal.git]
	Used GitHub name "Sergey Dobrodey" for sergeydobrodey <sergey.dobrodey@synesis.ru> https://github.com/golang/net/commit/e869164 [net]
	Used GitHub name "Tai Le" for Tai <letientai299@gmail.com> https://github.com/golang/build/commit/1b388d2 [build tools]
	Used GitHub name "WEI Xikai" for ShiKaiWi <xykwei@gmail.com> https://github.com/golang/go/commit/518ee55d78 [go]
	Used GitHub name "Yang Tian" for taoyuanyuan <linuxty@gmail.com> https://github.com/golang/go/commit/5eeb372418 [go]
	Used GitHub name "Zach Jones" for zdjones <zachj1@gmail.com> https://github.com/golang/go/commit/c178389604 [go]

Updates #12042

Change-Id: Ic220d997a0dc3bf4109ab964cbb6a25ea5c0c9da
Reviewed-on: https://go-review.googlesource.com/c/go/+/186397
Reviewed-by: Alexander Rakoczy <alex@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
