Core Git translation language teams
(please keep the list sorted alphabetically on language field)

Language:	da (Danish)
Repository:	https://github.com/git-da/git-po/
Leader:		Byrial Jensen <byrial@vip.cybercity.dk>

Language:	de (German)
Repository:	https://github.com/ralfth/git-po-de
Leader:		Ralf Thielow <ralf.thielow@googlemail.com>
Members:	Thomas Rast <trast@student.ethz.ch>
		Jan Krüger <jk@jk.gs>
		Christian Stimming <stimming@tuhh.de>

Language:	fr (French)
Repository:	https://github.com/jnavila/git
Leader:		Jean-Noël Avila <jn.avila@free.fr>
Members:	Sébastien Helleu <flashcode@flashtux.org>

Language:	is (Icelandic)
Leader:		Ævar Arnfjörð Bjarmason <avarab@gmail.com>

Language:	it (Italian)
Repository:	https://github.com/quizzlo/git-po-it/
Leader:		Marco Paolone <marcopaolone AT gmail.com>
Members:	Stefano Lattarini <stefano.lattarini AT gmail.com>

Language:	nl (Dutch)
Repository:	https://github.com/vfr-nl/git-po/
Leader:		Vincent van Ravesteijn <vfr@lyx.org>

Language:	pt_PT (Portuguese - Portugal)
Repository:	https://github.com/marcomsousa/git-l10n-pt_PT/
Leader:		Marco Sousa <marcomsousa AT gmail.com>

Language:	sv (Swedish)
Repository:	https://github.com/nafmo/git-l10n-sv/
Leader:		Peter Krefting <peter@softwolves.pp.se>

Language:	vi (Vietnamese)
Repository:	https://github.com/vnwildman/git/
Leader:		Trần Ngọc Quân <vnwildman AT gmail.com>
Members:	Nguyễn Thái Ngọc Duy <pclouds AT gmail.com>

Language:	zh_CN (Simplified Chinese)
Repository:	https://github.com/gotgit/git-po-zh_CN/
Leader:		Jiang Xin <worldhello.net@gmail.com>
Members:	Riku <lu.riku AT gmail.com>
		Zhuang Ya <zhuangya AT me.com>
		Lian Cheng <rhythm.mail AT gmail.com>
		Yichao Yu <yyc1992 AT gmail.com>
		ws3389 <willsmith3389 AT gmail.com>
		Thynson <lanxingcan AT gmail.com>
		Wang Sheng <wangsheng2008love@163.com>
