<!DOCTYPE HTML PUBLIC "-//SoftQuad Software//DTD HoTMetaL PRO 6.0::19990601::extensions to HTML 4.0//EN" "hmpro6.dtd">
<HTML> 
  <HEAD> <META NAME="Description" CONTENT="KDE Translation Teams">
	 <META NAME="Keywords"
	  CONTENT="kde internationalization i18n translation teams language po files 
documentation"> 
	 <TITLE>The KDE Translation Teams</TITLE> 
  </HEAD> 
  <BODY TEXT="#000000" BGCOLOR="#FFFFFF" LINK="#191970" VLINK="#551A8A"
	ALINK="#FE0000"> 
	 <CENTER> 
		<TABLE BORDER="0" CELLSPACING="0" CELLPADDING="0" WIDTH="75%"> 
		  <TR VALIGN="TOP"> 
			 <TD> 
				<H1>The KDE Translation Teams</H1> 
				<P>Many KDE applications have been translated to <B>more than 50
				  languages</B> already and the number of both the translated applications and
				  the supported languages is still growing. For information on how complete the
				  translation of the current KDE user interface to the individual languages
				  really is please see the respective <A
				  HREF="../stats/gui/i18n-table-HEAD.html">statistics page</A>. (<A
				  HREF="http://i18n.kde.org/stats/doc/">Documentation translation</A> is still in
				  its first stages for many teams.) The languages distributed with the last
				  official KDE version are listed on a <A HREF="distributed.html">separate
				  page</A>.</P> 
				<P> Almost all language teams are looking for additional
				  translators. And, of course, there are still a lot of languages missing in KDE.
				  So if you have some spare time and a good knowledge of English, please consider
				  joining one of the teams and help translating KDE to your native language. Just
				  write to the appropriate team coordinator in the list below. If there's no
				  coordinator listed for your language, take a look at the
				  <A HREF="../translation-howto/">Translation HOWTO</A> for more information on
				  how new languages are introduced to KDE and subscribe to the
				  <A HREF="http://master.kde.org/mailman/listinfo/kde-i18n-doc/">mailinglist</A>
				  for translators and documenters.</P> 
				<P>The team table below is sorted according to the official lists
				  of ISO&nbsp;639 language codes. (See
				  <A
				  HREF="http://lcweb.loc.gov/standards/iso639-2/englangn.html">http://lcweb.loc.g
				  ov/standards/iso639-2/englangn.html</A><A
				  HREF="http://www.dsv.su.se/~jpalme/ietf/language-codes.html"></A>). We are
				  presently switching from the 2-letter codes to the 3-letter codes.) In addition
				  to the basic team data like the <STRONG>coordinator(s)</STRONG>, the
				  <STRONG>mailing list</STRONG>, and the <STRONG>team's web site</STRONG>, the
				  list now contains links to:</P> 
				<UL TYPE="SQUARE"> 
				  <LI>compressed <STRONG>archives of all GUI and documentation
					 files</STRONG> that were already translated by the respective language team;
					 these files are usually of the type ".po" (GNU gettext) and ".docbook"
					 (XML)</LI> 
				  <LI>text files that contain <STRONG>all message strings of the
					 translated .po</STRONG> files -- these files are sometimes called
					 <STRONG>"compendia"</STRONG> and are used for instance by specialized
					 translation programs like <A HREF="../tools/kbabel/">KBabel</A> (the
					 recommended one for KDE translation).</LI> 
				  <LI>the <STRONG>"highscore list"</STRONG> for each team: an
					 overview which .po files were already translated but are in need of an
					 overhaul.</LI> 
				  <LI>the <STRONG>doc statistics</STRONG>: an overview of the
					 current status if there are any doc translations available</LI> 
				</UL> </TD> 
		  </TR> 
		</TABLE> 
		<TABLE BORDER="0" CELLSPACING="0" CELLPADDING="5" WIDTH="75%"
		 VALIGN="TOP" VSPACE="10"> 
		  <TR> 
			 <TD HEIGHT="5"><A NAME="team_table"></A>&nbsp;</TD> 
		  </TR>
<!-- Afrikaans -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="af">af</A></TH> 
			 <TH ALIGN="LEFT">Afrikaans team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF" VALIGN="MIDDLE"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): <A
					 HREF="mailto:frix@expertron.co.za">Frikkie Thirion</A></LI> 
				  <LI>mailing list: send an empty mail to
					 <A HREF="mailto:lia-subscribe@af.org.za">lia-subscribe@af.org.za</A></LI> 
				  <LI>web site: <A
					 HREF="http://kde.af.org.za/">kde.af.org.za</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-af.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-af.tar.bz2</A>
					 <BR> (size:&nbsp; 1.7M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/af.messages.bz2">i18n.kde.org/po_overview/af.messages.bz2</A><BR>
					 (size:&nbsp; 464k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/af-highscore.html">i18n.kde.org/stats/gui/af-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Arabic -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="ar">ara</A></TH> 
			 <TH ALIGN="LEFT">Arabic team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF" VALIGN="MIDDLE"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): <A
					 HREF="mailto:contact@arabeyes.org">Mohammed Elzubeir</A></LI> 
				  <LI>mailing list: doc@arabeyes.org (subscribe via
					 <A
					  HREF="http://www.arabeyes.org/cgi-bin/mailman/listinfo/doc/">www.arabeyes.org/cgi-bin/mailman/listinfo/doc</A>)</LI>
				  
				  <LI>web site: <A
					 HREF="http://www.arabeyes.org/">www.arabeyes.org</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-ara.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-ara.tar.bz2</A>
					 <BR> (size:&nbsp; 429k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/ara.messages.bz2">i18n.kde.org/po_overview/ara.messages.bz2</A><BR>
					 (size:&nbsp;  85k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/ara-highscore.html">i18n.kde.org/stats/gui/ara-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Azerbaijani Turkish -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="az">az</A></TH> 
			 <TH ALIGN="LEFT">Azerbaijani team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF" VALIGN="MIDDLE"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): <A
					 HREF="mailto:azerb_linux@yahoo.com">Vasif Ismailoglu</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: <A
					 HREF="http://www.linuxaz.com/">www.linuxaz.com</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-az.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-az.tar.bz2</A>
					 <BR> (size:&nbsp; 1.7M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/az.messages.bz2">i18n.kde.org/po_overview/az.messages.bz2<BR>
					 (size:&nbsp; 480k)</A></LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/az-highscore.html">i18n.kde.org/stats/gui/az-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR> 
		  <TR BGCOLOR="#C8C8FF">
<!-- Bulgarian -->
			 <TH ALIGN="LEFT"><A NAME="bg">bg</A></TH> 
			 <TH ALIGN="LEFT">Bulgarian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF" VALIGN="MIDDLE"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s):
					 <A HREF="mailto:vesselina@galgenberg.net">Vesselina Nikolova</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site:
					 <A
					  HREF="http://www.galgenberg.net/~vesselina/bg.html">www.galgenberg.net/~vesseli
					 na/bg.html</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-bg.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-bg.tar.bz2</A>
					 <BR> (size:&nbsp; 1.5M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/bg.messages.bz2">i18n.kde.org/po_overview/bg.messages.bz2</A><BR>
					 (size:&nbsp;  12k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/bg-highscore.html">i18n.kde.org/stats/gui/bg-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR> 
		  <TR BGCOLOR="#C8C8FF"> 
<!-- Bengali -->
			 <TH ALIGN="LEFT"><A NAME="bn">bn</A></TH> 
			 <TH ALIGN="LEFT">Bengali team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF" VALIGN="MIDDLE"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s):
					 <A HREF="mailto:taneem.ahmed@latticesemi.com">Ahmed, Taneem</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive:--</LI> 
				  <LI>.po messages translated: --</LI> 
				  <LI>.po files in need of a revision: --</LI> 
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR> 
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="bo">bo</A></TH> 
			 <TH ALIGN="LEFT">Tibetan team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF" VALIGN="MIDDLE"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): <A
					 HREF="mailto:norbu@t-online.de">Katrin Norbu</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive:--</LI> 
				  <LI>.po messages translated: --</LI> 
				  <LI>.po files in need of a revision: --</LI> 
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Breton -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="br">br</A></TH> 
			 <TH ALIGN="LEFT">Breton team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF" VALIGN="MIDDLE"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s):
					 <A HREF="mailto:jdrapier@club-internet.fr">Ja&ntilde;-Mai Drapier</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: <A
					 HREF="http://perso.club-internet.fr/jdrapier">perso.club-internet.fr/jdrapier</A></LI>
				  
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-br.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-br.tar.bz2</A>
					 <BR> (size:&nbsp; 548k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/br.messages.bz2">i18n.kde.org/po_overview/br.messages.bz2</A><BR>
					 (size:&nbsp;  62k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/br-highscore.html">i18n.kde.org/stats/gui/br-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Bosnian -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="bs">bs</A></TH> 
			 <TH ALIGN="LEFT">Bosnian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF" VALIGN="MIDDLE"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:bianchi@lugbih.org">Neshiren
					 Armin</A>, <A HREF="mailto:bono@lugbih.org">Amila Akagic</A></LI> 
				  <LI>mailing list: Send mail to
					 <A HREF="mailto:kde-subscribe@lugbih.org">kde-subscribe@lugbih.org</A></LI> 
				  <LI>web site: <A
					 HREF="http://kde.lugbih.org/">kde.lugbih.org</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-bs.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-bs.tar.bz2</A>
					 <BR> (size:&nbsp; 274k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/bs.messages.bz2">i18n.kde.org/po_overview/bs.messages.bz2</A>
					 <BR> (size:&nbsp;  28k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/bs-highscore.html">i18n.kde.org/stats/gui/bs-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Catalan -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="ca">ca</A></TH> 
			 <TH ALIGN="LEFT">Catalan team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): <A
					 HREF="mailto:sastia@redestb.es">Sebasti&agrave; Pla</A></LI> 
				  <LI>mailing list: send a mail with "subscribe" in the subject
					 line to: <A
					 HREF="mailto:linux-ca-request@chanae.alphanet.ch">linux-ca-request@chanae.alpha
					 net.ch</A></LI> 
				  <LI>web site:
					 <A
					  HREF="http://linux.softcatala.org/projectes/kde/">linux.softcatala.org/projecte
					 s/kde/</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-ca.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-ca.tar.bz2</A><BR>
					 (size:&nbsp; 920k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/ca.messages.bz2">i18n.kde.org/po_overview/ca.messages.bz2</A><BR>
					 (size:&nbsp; 183k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/ca-highscore.html">i18n.kde.org/stats/gui/ca-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Czech -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="cs">cs</A></TH> 
			 <TH ALIGN="LEFT">Czech team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:flidr@kky.zcu.cz">Miroslav
					 Fl&iacute;dr</A> (GUI), <A HREF="mailto:lukas@kde.org">Luk&aacute;&scaron;
					 Tinkl</A> (documentation)</LI> 
				  <LI>mailing list: kde-czech-apps@lists.sourceforge.net</LI> 
				  <LI>web site: <A
					 HREF="http://kde-czech.sourceforge.net/">kde-czech.sourceforge.net</A></LI> 
				  <LI>(Subscription via
					 <A
					  HREF="http://lists.sourceforge.net/lists/listinfo/kde-czech-apps/">lists.sourceforge.net/lists/listinfo/kde-czech-apps</A>)
					 </LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-cs.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-cs.tar.bz2</A>
					 <BR> (size:&nbsp; 1.9M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/cs.messages.bz2">i18n.kde.org/po_overview/cs.messages.bz2</A>
					 <BR> (size:&nbsp; 549k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/cs-highscore.html">i18n.kde.org/stats/gui/cs-highscore.html</A></LI>
				  
				  <LI>doc statistics:
					 <A
					  HREF="http://i18n.kde.org/stats/doc/index.php?team=cs">i18n.kde.org/stats/doc/index.php?team=cs</A><A
					 HREF="../stats/doc/html/doc-cs.html"></A></LI> 
				</UL></TD> 
		  </TR>
<!-- Welsh -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="cy">cy</A></TH> 
			 <TH ALIGN="LEFT">Welsh team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:elf@uklinux.net">Elfed
					 Lewis</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-cy.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-cy.tar.bz2</A><BR>
					 (size:&nbsp; 205k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/cy.messages.bz2">i18n.kde.org/po_overview/cy.messages.bz2</A>
					 <BR> (size:&nbsp;  12k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="http://i18n.kde.org/stats/gui/cy-highscore.html">i18n.kde.org/stats/gui/cy-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Danish -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="da">da</A></TH> 
			 <TH ALIGN="LEFT">Danish team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:erik@binghamton.edu">Erik
					 Kj&aelig;r Pedersen</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-da.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-da.tar.bz2</A><BR>
					 (size:&nbsp; 4.5M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/da.messages.bz2">i18n.kde.org/po_overview/da.messages.bz2</A>
					 <BR> (size:&nbsp; 1.1M)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/da-highscore.html">i18n.kde.org/stats/gui/da-highscore.html</A></LI>
				  
				  <LI>doc statistics:
					 <A
					  HREF="http://i18n.kde.org/stats/doc/index.php?team=da">i18n.kde.org/stats/doc/index.php?team=da</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- German -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="de">de</A></TH> 
			 <TH ALIGN="LEFT">German team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:thd@kde.org">Thomas Diehl</A>
					 (GUI and documentation)<BR><A HREF="mailto:malte@knoerr.escape.de">Malte
					 Kn&ouml;rr</A> (web site)</LI> 
				  <LI>mailing lists: There are separate KDE and web translation
					 lists. To get on the KDE translation list (GUI and documentation) send mail
					 with "subscribe" in the subject line to
					 <A HREF="mailto:kde-i18n-de-request@kde.org">kde-i18n-de-request@kde.org</A>.
					 <BR>To get on the web site translation list send mail with "subscribe" in the
					 subject line to <A
					 HREF="mailto:www-de-request@kde.org">www-de-request@kde.org</A> </LI> 
				  <LI>team web site: <A HREF="de/">i18n.kde.org/teams/de/</A></LI> 
				  <LI>user web site:
					 <A
					  HREF="http://www.kde.org/international/germany/">www.kde.org/international/germ
					 any/</A></LI> 
				  <LI>web forum: <A
					 HREF="http://www.dtp-service.com/discus_d">www.dtp-service.com/discus_d/</A>
					 </LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-de.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-de.tar.bz2</A>
					 <BR> (size:&nbsp; 7.6M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/de.messages.bz2">i18n.kde.org/po_overview/de.messages.bz2</A>
					 <BR> (size:&nbsp; 1.3M)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/de-highscore.html">i18n.kde.org/stats/gui/de-highscore.html</A></LI>
				  
				  <LI>doc statistics:
					 <A
					  HREF="http://i18n.kde.org/stats/doc/index.php?team=de">i18n.kde.org/stats/doc/index.php?team=de</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- Greek -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="el">el</A></TH> 
			 <TH ALIGN="LEFT">Greek team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A
					 HREF="mailto:el97146@mail.ntua.gr">Dimitris Kamenopoulos</A></LI> 
				  <LI>mailing list: kdei18ngr@hellug.gr (to subscribe send mail to
					 <A HREF="mailto:majordomo@hellug.gr">majordomo@hellug.gr</A> with "subscribe
					 kdei18ngr" in the message body)</LI> 
				  <LI>web site: <A HREF="el/">i18n.kde.org/teams/el/</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-el.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-el.tar.bz2</A><BR>
					 (size:&nbsp; 934k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/el.messages.bz2">i18n.kde.org/po_overview/el.messages.bz2</A>
					 <BR> (size:&nbsp;   8k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/el-highscore.html">i18n.kde.org/stats/gui/el-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- British English -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="en_GB">en_GB</A></TH> 
			 <TH ALIGN="LEFT">British English Team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s):
					 <A HREF="mailto:anarchist_tomato@herzeleid.net">John Knight</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-en_GB.tar.b
z2">i18n.kde.org/translation_archive/kde-i18n-en_GB.tar.bz2</A><BR>
					 (size:&nbsp; 1.6M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/en_GB.messages.bz2">i18n.kde.org/po_overview/en_GB.message
					 s.bz2</A><BR> (size:&nbsp; 466k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/highscore-en_GB.html">i18n.kde.org/stats/gui/highscore-en_GB
					 .html</A></LI> 
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Esperanto -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="eo">eo</A></TH> 
			 <TH ALIGN="LEFT">Esperanto team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): <A
					 HREF="mailto:wolfram@steloj.de">Wolfram Diestel</A></LI> 
				  <LI>mailing list on translating Linux/GNU-applications (not
					 focussed on KDE): eo@li.org; send mail to <A HREF="mailto:majordomo@li.org">
					 majordomo@li.org</A> with "subscribe&nbsp;eo" in the message body</LI> 
				  <LI>web site:
					 <A
					  HREF="http://www.uni-leipzig.de/esperanto/material/kde/kde.html">www.uni-leipzi
					 g.de/esperanto/material/kde/kde.html</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-eo.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-eo.tar.bz2</A><BR>
					 (size:&nbsp; 1.4M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/eo.messages.bz2">i18n.kde.org/po_overview/eo.messages.bz2</A>
					 <BR> (size:&nbsp; 414k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/eo-highscore.html">i18n.kde.org/stats/gui/eo-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Spanish -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="es">es</A></TH> 
			 <TH ALIGN="LEFT">Spanish team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinators: <A HREF="mailto:jaime@kde.org">Jaime
					 Robles</A></LI> 
				  <LI>mailing list: send message to
					 <A HREF="mailto:majordomo@kybs.de">majordomo@kybs.de</A> with the words
					 "subscribe kde-es" in the body</LI> 
				  <LI>web site: <A HREF="es/">i18n.kde.org/teams/es/</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-es.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-es.tar.bz2</A><BR>
					 (size:&nbsp; 4.2M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/es.messages.bz2">i18n.kde.org/po_overview/es.messages.bz2</A>
					 <BR> (size:&nbsp;  38k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/es-highscore.html">i18n.kde.org/stats/gui/es-highscore.html</A></LI>
				  
				  <LI>doc statistics:
					 <A
					  HREF="http://i18n.kde.org/stats/doc/index.php?team=es">i18n.kde.org/stats/doc/index.php?team=es</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- Estonian -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="et">et</A></TH> 
			 <TH ALIGN="LEFT">Estonian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:hasso@estpak.ee">Hasso
					 Tepper</A></LI> 
				  <LI>mailing list: linux-ee@eenet.ee (for subscription send mail
					 to <A HREF="mailto:listproc@lists.edu.ee">listproc@lists.edu.ee</A> with body
					 "subscribe linux-ee firstname lastname")</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-et.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-et.tar.bz2</A><BR>
					 (size:&nbsp; 1.6M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/et.messages.bz2">i18n.kde.org/po_overview/et.messages.bz2</A><BR>
					 (size:&nbsp; 506k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/et-highscore.html">i18n.kde.org/stats/gui/et-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Basque -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="eu">eu</A></TH> 
			 <TH ALIGN="LEFT">Basque team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A
					 HREF="mailto:marcos@euskal-linux.org">Marcos Goienetxe</A></LI> 
				  <LI>mailing list: send mail with "subscribe" in the subject line
					 to: <A
					 HREF="mailto:linux-eu-request@chanae.alphanet.ch">linux-eu-request@chanae.alphanet.c</A>
					 </LI> 
				  <LI>web site: <A
					 HREF="http://kde.eu.euskal-linux.org/">kde.eu.euskal-linux.org</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-eu.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-eu.tar.bz2</A><BR>
					 (size:&nbsp; 567k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/eu.messages.bz2">i18n.kde.org/po_overview/eu.messages.bz2</A><BR>
					 (size:&nbsp;  86k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/eu-highscore.html">i18n.kde.org/stats/gui/eu-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Farsi -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="fa">fa</A></TH> 
			 <TH ALIGN="LEFT">Farsi (Persian) team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:a.zeini@iranlaico.com">Arash
					 Zeini</A></LI> 
				  <LI>mailing list: subscribe via
					 <A
					  HREF="http://lists.sharif.edu/mailman/listinfo/farsikde/">lists.sharif.edu/mailman/listinfo/farsikde</A></LI>
				  
				  <LI>web site: <A
					 HREF="http://www.farsikde.com/">www.farsikde.com</A></LI> 
				  <LI>.po and doc archive: --</LI> 
				  <LI>.po messages translated: --</LI> 
				  <LI>.po files in need of a revision: --</LI> 
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Finnish -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="fi">fi</A></TH> 
			 <TH ALIGN="LEFT">Finnish team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:kim.enkovaara@iki.fi">Kim
					 Enkovaara</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: <A
					 HREF="http://kde-i18n-fi.sourceforge.net">kde-i18n-fi.sourceforge.net</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-fi.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-fi.tar.bz2</A><BR>
					 (size:&nbsp; 1.5M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/fi.messages.bz2">i18n.kde.org/po_overview/fi.messages.bz2</A><BR>
					 (size:&nbsp;  86k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/fi-highscore.html">i18n.kde.org/stats/gui/fi-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Faroese -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="fo">fo</A></TH> 
			 <TH ALIGN="LEFT">Faroese team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A
					 HREF="mailto:a-nielsen@post.olivant.fo">Aki Nielsen</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive: --</LI> 
				  <LI>.po messages translated: --</LI> 
				  <LI>.po files in need of a revision: --</LI> 
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR> 
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="fr">fr</A></TH> 
			 <TH ALIGN="LEFT">French team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): <BR> <A
					 HREF="mailto:cousin@in2p3.fr">Thibaut Cousin</A> (GUI translation)<BR>
					 <A HREF="mailto:ludovic.grossard@libertysurf.fr">Ludovic Grossard</A>
					 (documentation translation)<BR> <A HREF="mailto:tells@mygale.com">Serge
					 'Sergio' Tellene</A> (web server translation).</LI> 
				  <LI>mailing list: send an empty mail to
					 <A
					  HREF="mailto:kde-francophone-subscribe@kde.org">kde-francophone-subscribe@kde.org</A>
					 </LI> 
				  <LI>team web site: <A
					 HREF="http://i18n.kde.org/teams/fr/">i18n.kde.org/teams/fr/</A></LI> 
				  <LI>user web site: <A
					 HREF="http://www.kde.org/fr/">www.kde.org/fr</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-fr.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-fr.tar.bz2</A><BR>
					 (size:&nbsp; 6.9M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/fr.messages.bz2">i18n.kde.org/po_overview/fr.messages.bz2</A><BR>
					 (size:&nbsp;  26k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/fr-highscore.html">i18n.kde.org/stats/gui/fr-highscore.html</A></LI>
				  
				  <LI>doc statistics:
					 <A
					  HREF="http://i18n.kde.org/stats/doc/index.php?team=fr">i18n.kde.org/stats/doc/index.php?team=fr</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- Irish Gaelic-->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="ga">ga</A></TH> 
			 <TH ALIGN="LEFT">Irish Gaelic team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A
					 HREF="mailto:soc@users.sourceforge.net">Sean V. Kelley</A></LI> 
				  <LI>mailing list: see
					 <A
					  HREF="http://lists.sourceforge.net/mailman/listinfo/gaeilge-gnulinux">lists.sourceforge.net/mailman/listinfo/gaeilge-gnulinux</A></LI>
				  
				  <LI>web site: <A
					 HREF="http://gaeilge.sourceforge.net/">gaeilge.sourceforge.net</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-ga.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-ga.tar.bz2</A><BR>
					 (size:&nbsp; 218k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/ga.messages.bz2">i18n.kde.org/po_overview/ga.messages.bz2</A><BR>
					 (size:&nbsp;   2k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/ga-highscore.html">i18n.kde.org/stats/gui/ga-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Gujarati -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT">gl</TH> 
			 <TH ALIGN="LEFT">Gallegan team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:lodoss@gpul.org">Alejandro
					 Pose Rey</A>, <A HREF="mailto:jba@pobox.com">Jes&uacute;s Bravo
					 &Aacute;lvarez</A></LI> 
				  <LI>mailing list: trasno@ceu.fi.udc.es (for information about how
					 to subscribe, visit <A
					 HREF="http://trasno.gpul.org/axuda/lista.php">trasno.gpul.org/axuda/lista.php</A>)</LI>
				  
				  <LI>web site: <A
					 HREF="http://trasno.gpul.org/kde/">trasno.gpul.org/kde/</A></LI> 
				  <LI>.po and doc archive: --</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/gl.messages.bz2">i18n.kde.org/po_overview/gl.messages.bz2</A><BR>
					 (size:&nbsp;  64k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/gl-highscore.html">i18n.kde.org/stats/gui/gl-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR> 
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="gu">gu</A></TH> 
			 <TH ALIGN="LEFT">Gujarati team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:apu@freeos.com">Apu
					 Shah</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive: --</LI> 
				  <LI>.po messages translated: --</LI> 
				  <LI>.po files in need of a revision: --</LI> 
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR> 
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="he">he</A></TH> 
			 <TH ALIGN="LEFT">Hebrew team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:livne@kde.org">Meni
					 Livne</A></LI> 
				  <LI>mailing list: <A
					 HREF="http://groups.yahoo.com/group/kde-il/">groups.yahoo.com/group/kde-il</A></LI>
				  
				  <LI>web site: <A
					 HREF="http://www.kde.org/il/hebrew/ ">www.kde.org/il/hebrew</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-he.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-he.tar.bz2</A><BR>
					 (size:&nbsp; 1.5M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/he.messages.bz2">i18n.kde.org/po_overview/he.messages.bz2</A><BR>
					 (size:&nbsp; 381k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/he-highscore.html">i18n.kde.org/stats/gui/he-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Hindi -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="hi">hi</A></TH> 
			 <TH ALIGN="LEFT">Hindi team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:harshkumar@vsnl.com">Harsh
					 Kumar</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive: --</LI> 
				  <LI>.po messages translated: --</LI> 
				  <LI>.po files in need of a revision: --</LI> 
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR> 
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="hr">hr</A></TH> 
			 <TH ALIGN="LEFT">Croatian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s):
					 <A HREF="http://www.linux.hr/~vkosturj/mail.php">Vlatko Kosturjak</A></LI> 
				  <LI>mailing list: send mail to
					 <A
					  HREF="mailto:lokalizacija-subscribe@linux.hr">lokalizacija-subscribe@linux.hr</A>
					 </LI> 
				  <LI>web site: <A
					 HREF="http://lokalizacija.linux.hr/kde/">lokalizacija.linux.hr/kde/</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-hr.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-hr.tar.bz2</A><BR>
					 (size:&nbsp; 894k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/hr.messages.bz2">i18n.kde.org/po_overview/hr.messages.bz2</A><BR>
					 (size:&nbsp; 143k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/hr-highscore.html">i18n.kde.org/stats/gui/hr-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Hungarian -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="hu">hu</A></TH> 
			 <TH ALIGN="LEFT">Hungarian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:miketkf@yahoo.com">Marcell
					 Lengyel</A></LI> 
				  <LI>mailing list: kde-lista@sophia.jpte.hu (to get in send mail
					 with "subscribe" in the body to
					 <A
					  HREF="mailto:kde-lista-request@sophia.jpte.hu">kde-lista-request@sophia.jpte.hu</A>)</LI>
				  
				  <LI>web site: <A HREF="http://www.kde.hu/">www.kde.hu</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-hu.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-hu.tar.bz2</A><BR>
					 (size:&nbsp; 2.7M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/hu.messages.bz2">i18n.kde.org/po_overview/hu.messages.bz2</A><BR>
					 (size:&nbsp;[an error occurred while processing this directive])</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/hu-highscore.html">i18n.kde.org/stats/gui/hu-highscore.html</A></LI>
				  
				  <LI>doc statistics:
					 <A
					  HREF="http://i18n.kde.org/stats/doc/index.php?team=hu">i18n.kde.org/stats/doc/index.php?team=hu</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- Indonesian -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="id">id/ind</A></TH> 
			 <TH ALIGN="LEFT">Indonesian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s):
					 <A HREF="mailto:made@nakula.rvs.uni-bielefeld.de">I Made Wiryana</A>,
					 <A HREF="mailto:haris@trustix.com">Haris Fauzi</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: <A
					 HREF="http://merdeka.trustix.co.id/kde/">merdeka.trustix.co.id/kde</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-ind.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-ind.tar.bz2</A>
					 <BR> (size:&nbsp; 1.5M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/ind.messages.bz2">i18n.kde.org/po_overview/ind.messages.bz2</A><BR>
					 (size:&nbsp; 390k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/ind-highscore.html">i18n.kde.org/stats/gui/ind-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Icelandic -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="is">is</A></TH> 
			 <TH ALIGN="LEFT">Icelandic team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): <A HREF="mailto:logir@logi.org">Logi
					 Ragnarsson</A>, <A HREF="mailto:thori@mindspring.com">Thorarinn R.
					 Einarsson</A>, <A HREF="mailto:bre@mmedia.is">Bjarni R. Einarsson</A></LI> 
				  <LI>mailing list: kde-isl@mmedia.is (no subscription info
					 available yet)</LI> 
				  <LI>web site: <A
					 HREF="http://www.is.kde.org/">www.is.kde.org</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-is.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-is.tar.bz2</A><BR>
					 (size:&nbsp; 1.2M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/is.messages.bz2">i18n.kde.org/po_overview/is.messages.bz2</A><BR>
					 (size:&nbsp;   1k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/is-highscore.html">i18n.kde.org/stats/gui/is-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>

<!-- Italian -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="it">it</A></TH> 
			 <TH ALIGN="LEFT">Italian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:rizzi@kde.org">Andrea
					 Rizzi</A></LI> 
				  <LI>mailing list: send mail with "subscribe" in the subject line
					 to: <A
					 HREF="mailto:kde-i18n-it-request@kde.org">kde-i18n-it-request@kde.org</A></LI> 
				  <LI>web site: <A
					 HREF="it/index.html">i18n.kde.org/teams/it/</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-it.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-it.tar.bz2</A><BR>
					 (size:&nbsp; 1.8M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/it.messages.bz2">i18n.kde.org/po_overview/it.messages.bz2</A>
					 <BR> (size:&nbsp; 520k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/it-highscore.html">i18n.kde.org/stats/gui/it-highscore.html</A></LI>
				  
				  <LI>doc statistics:
					 <A
					  HREF="http://i18n.kde.org/stats/doc/index.php?team=it">i18n.kde.org/stats/doc/index.php?team=it</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- Japanese -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="ja">ja</A></TH> 
			 <TH ALIGN="LEFT">Japanese team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:tklab@pa3.so-net.ne.jp">Taiki
					 Komoda</A></LI> 
				  <LI>mailing list: send mail to
					 <A HREF="mailto:Kuser-ctl@kde.gr.jp">Kuser-ctl@kde.gr.jp</A> with "subscribe"
					 in the message body.</LI> 
				  <LI>web site: <A
					 HREF="http://www.kde.gr.jp/">www.kde.gr.jp</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-ja.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-ja.tar.bz2</A><BR>
					 (size:&nbsp; 1.5M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/ja.messages.bz2">i18n.kde.org/po_overview/ja.messages.bz2</A><BR>
					 (size:&nbsp;[an error occurred while processing this directive])</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/ja-highscore.html">i18n.kde.org/stats/gui/ja-highscore.html</A></LI>
				  
				  <LI>doc statistics:
					 <A
					  HREF="http://i18n.kde.org/stats/doc/index.php?team=ja">i18n.kde.org/stats/doc/index.php?team=ja</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- Khmer/Cambodian -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="km">km</A></TH> 
			 <TH ALIGN="LEFT">Khmer (Cambodian) team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:kcra@sanetech.com">Neang,
					 Savun</A></LI> 
				  <LI>mailing list: kdelist@khmermp3.com (no subscription info
					 available yet)</LI> 
				  <LI>web site: <A
					 HREF="http://kde.khmermp3.com/">kde.khmermp3.com</A></LI> 
				  <LI>.po and doc archive: --</LI> 
				  <LI>.po messages translated: --</LI> 
				  <LI>.po files in need of a revision: --</LI> 
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Korean -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="ko">ko</A></TH> 
			 <TH ALIGN="LEFT">Korean team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:tody@mizi.com">KIM
					 KyungHeon</A></LI> 
				  <LI>mailing list: kde-i18n@kldp.org (use the web page at
					 <A
					  HREF="http://list.kldp.org/mailman/listinfo/kde-i18n/">list.kldp.org/mailman/listinfo/kde-i18n/</A>
					 to subscribe)</LI> 
				  <LI>team web site: <A
					 HREF="http://www.kde.or.kr/">www.kde.or.kr</A><A
					 HREF="http://www.kde.or.kr/"></A></LI> 
				  <LI>user web site: <A
					 HREF="http://kde.kldp.org/">kde.kldp.org</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-ko.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-ko.tar.bz2</A><BR>
					 (size:&nbsp; 991k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/ko.messages.bz2">i18n.kde.org/po_overview/ko.messages.bz2</A><BR>
					 (size:&nbsp;  10k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/ko-highscore.html">i18n.kde.org/stats/gui/ko-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Kurdish -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="ku">kur</A></TH> 
			 <TH ALIGN="LEFT">Kurdish team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): <A HREF="mailto:kde-ku@pispor.com">Abou
					 Gerdi</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-kur.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-kur.tar.bz2</A>
					 <BR> (size:&nbsp; 232k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/kur.messages.bz2">i18n.kde.org/po_overview/kur.messages.bz2</A><BR>
					 (size:&nbsp;  33k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/kur-highscore.html">i18n.kde.org/stats/gui/kur-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR> 
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="lt">lt</A></TH> 
			 <TH ALIGN="LEFT">Lithuanian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:rch@richard.eu.org">Richard
					 Cepas</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-lt.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-lt.tar.bz2</A><BR>
					 (size:&nbsp; 948k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/lt.messages.bz2">i18n.kde.org/po_overview/lt.messages.bz2</A><BR>
					 (size:&nbsp; 270k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/lt-highscore.html">i18n.kde.org/stats/gui/lt-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Latvian -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT">lv</TH> 
			 <TH ALIGN="LEFT">Latvian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:andris.m@delfi.lv">Andris
					 Maziks</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive: --<BR></LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/lv.messages.bz2">i18n.kde.org/po_overview/lv.messages.bz2</A><BR>
					 (size:&nbsp; 247k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/lv-highscore.html">i18n.kde.org/stats/gui/lv-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR> 
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT">mi</TH> 
			 <TH ALIGN="LEFT">Maori team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <B>unmaintained</B></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-mi.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-mi.tar.bz2</A><BR>
					 (size:&nbsp; 230k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/mi.messages.bz2">i18n.kde.org/po_overview/mi.messages.bz2</A><BR>
					 (size:&nbsp;   9k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/mi-highscore.html">i18n.kde.org/stats/gui/mi-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Macedonian -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="mk">mk</A></TH> 
			 <TH ALIGN="LEFT">Macedonian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:danko@mindless.com">Danko
					 Ilik</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: <A
					 HREF="http://slavej.pmf.ukim.edu.mk/">slavej.pmf.ukim.edu.mk</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-mk.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-mk.tar.bz2</A><BR>
					 (size:&nbsp; 700k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/mk.messages.bz2">i18n.kde.org/po_overview/mk.messages.bz2</A><BR>
					 (size:&nbsp; 122k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/mk-highscore.html">i18n.kde.org/stats/gui/mk-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Marathi -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="mr">mr</A></TH> 
			 <TH ALIGN="LEFT">Marathi team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:palkar@poboxes.com">Rahul
					 Palkar</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive: --</LI> 
				  <LI>.po messages translated: --</LI> 
				  <LI>.po files in need of a revision: --</LI> 
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Maltese -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="mt">mt</A></TH> 
			 <TH ALIGN="LEFT">Maltese team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:rcasha@waldonet.net.mt">Ramon
					 Casha</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive: --</LI> 
				  <LI>.po messages translated: --</LI> 
				  <LI>.po files in need of a revision: --</LI> 
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Dutch -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="nl">nl</A></TH> 
			 <TH ALIGN="LEFT">Dutch team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): <A HREF="mailto:rinse@kde.nl">Rinse de
					 Vries</A>, see also contact list at <A
					 HREF="http://www.kde.nl/nl/contact.html">www.kde.nl/nl/contact.html</A></LI> 
				  <LI>mailing list: i18n@kde.nl (send an empty message to
					 <A HREF="mailto:kde-nl-subscribe@egroups.com">kde-nl-subscribe@egroups.com</A>
					 to subscribe)</LI> 
				  <LI>mailing list archive:
					 <A HREF="http://www.egroups.com/group/kde-nl/">www.egroups.com/group/kde-nl</A>
					 </LI> 
				  <LI>web site: <A
					 HREF="http://www.kde.nl/nl/">www.kde.nl/nl</A></LI> 
				  <LI>user web site: <A
					 HREF="http://www.kde.nl/">www.kde.nl</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-nl.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-nl.tar.bz2</A><BR>
					 (size:&nbsp; 2.8M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/nl.messages.bz2">i18n.kde.org/po_overview/nl.messages.bz2</A><BR>
					 (size:&nbsp; 741k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/nl-highscore.html">i18n.kde.org/stats/gui/nl-highscore.html</A></LI>
				  
				  <LI>doc statistics:
					 <A
					  HREF="http://i18n.kde.org/stats/doc/index.php?team=nl">i18n.kde.org/stats/doc/index.php?team=nl</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- Norwegian/Bokmaal -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="no">no</A></TH> 
			 <TH ALIGN="LEFT">Norwegian (Bokm&aring;l) team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A
					 HREF="mailto:number1@realityx.net">Christian A. Str&oslash;mmen</A></LI> 
				  <LI>web site: --</LI> 
				  <LI>mailing list: --</LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-no.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-no.tar.bz2</A><BR>
					 (size:&nbsp; 1.7M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/no.messages.bz2">i18n.kde.org/po_overview/no.messages.bz2</A><BR>
					 (size:&nbsp;  89k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/no-highscore.html">i18n.kde.org/stats/gui/no-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Norwegian/Nynorsk -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="no_NY">no_NY</A></TH> 
			 <TH ALIGN="LEFT">Norwegian (Nynorsk) team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:gaute@verdsveven.com">Gaute
					 Hvoslef Kvalnes</A></LI> 
				  <LI>web site: <A
					 HREF="http://i18n.kde.org/teams/no_NY/">i18n.kde.org/teams/no_NY</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-no_NY.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-no_NY.tar.bz2</A><BR>
					 (size:&nbsp; 1.6M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/no_NY.messages.bz2">i18n.kde.org/po_overview/no_NY.messages.bz2</A><BR>
					 (size:&nbsp; 466k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/no_NY-highscore.html">i18n.kde.org/stats/gui/no_NY-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Occitan -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="oc">oc</A></TH> 
			 <TH ALIGN="LEFT">Occitan team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A
					 HREF="mailto:laborde@crpp.u-bordeaux.fr">Joan Luc Lab&ograve;rda</A></LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-oc.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-oc.tar.bz2</A><BR>
					 (size:&nbsp; 306k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/oc.messages.bz2">i18n.kde.org/po_overview/oc.messages.bz2</A><BR>
					 (size:&nbsp;  34k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/oc-highscore.html">i18n.kde.org/stats/gui/oc-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR> 
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="pl">pl</A></TH> 
			 <TH ALIGN="LEFT">Polish team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s):
					 <A HREF="mailto:jacek@mer.chemia.polsl.gliwice.pl">Jacek Stolarczyk</A></LI> 
				  <LI>mailing list: kde-transl@mer.chemia.polsl.gliwice.pl (to
					 subscribe send an empty mail to
					 <A
					  HREF="mailto:kde-transl-request@mer.chemia.polsl.gliwice.pl">kde-transl-request@mer.chemia.polsl.gliwice.pl</A>)</LI>
				  
				  <LI>web site:
					 <A
					  HREF="http://mer.chemia.polsl.gliwice.pl/kde/transl/">mer.chemia.polsl.gliwice.pl/kde/transl/</A></LI>
				  
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-pl.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-pl.tar.bz2</A><BR>
					 (size:&nbsp; 1.5M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/pl.messages.bz2">i18n.kde.org/po_overview/pl.messages.bz2</A><BR>
					 (size:&nbsp;  10k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/pl-highscore.html">i18n.kde.org/stats/gui/pl-highscore.html</A><BR>(more
					 info at <A
					 HREF="http://mer.chemia.polsl.gliwice.pl/kde/transl/pliki-po/">mer.chemia.polsl.gliwice.pl/kde/transl/pliki-po/</A>)</LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Portuguese -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="pt">pt</A></TH> 
			 <TH ALIGN="LEFT">Portuguese team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:morais@kde.org">Pedro
					 Morais</A></LI> 
				  <LI>mailing list: kde@poli.org (for subscription send mail to
					 Pedro Morais)</LI> 
				  <LI>web site: <A
					 HREF="http://kde.poli.org/">kde.poli.org</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-pt.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-pt.tar.bz2</A><BR>
					 (size:&nbsp; 2.1M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/pt.messages.bz2">i18n.kde.org/po_overview/pt.messages.bz2</A><BR>
					 (size:&nbsp; 648k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/pt-highscore.html">i18n.kde.org/stats/gui/pt-highscore.html</A></LI>
				  
				  <LI>doc statistics:
					 <A
					  HREF="http://i18n.kde.org/stats/doc/index.php?team=pt">i18n.kde.org/stats/doc/index.php?team=pt</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- Brazilian Portuguese -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="pt_BR">pt_BR</A></TH> 
			 <TH ALIGN="LEFT">Brazilian Portuguese team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): 
					 <A HREF="mailto:maragato@kde.org">Roberto Teixeira</A></LI>
				  <LI>mailing list: ldp-br@bazar.conectiva.com.br (see the
					 <A HREF="http://ldp-br.conectiva.com.br/?lista">web site</A> for subscription
					 info)</LI> 
				  <LI>web site: <A
					 HREF="http://ldp-br.conectiva.com.br">ldp-br.conectiva.com.br</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-pt_BR.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-pt_BR.tar.bz2</A><BR>
					 (size:&nbsp; 1.4M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/pt_BR.messages.bz2">i18n.kde.org/po_overview/pt_BR.messages.bz2</A><BR>
					 (size:&nbsp;  28k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/pt_BR-highscore.html">i18n.kde.org/stats/gui/pt_BR-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Romanian -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="ro">ro</A></TH> 
			 <TH ALIGN="LEFT">Romanian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): <A
					 HREF="mailto:claudiuc@work.ro">Claudiu Costin</A>,
					 <A HREF="mailto:florin@bnv-bamberg.de">Florin Boariu</A></LI> 
				  <LI>mailing list: See
					 <A HREF="http://www.egroups.com/group/ro-kde/">www.egroups.com/group/ro-kde</A>
					 </LI> 
				  <LI>web site: <A
					 HREF="http://www.ro.kde.org/">www.ro.kde.org</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-ro.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-ro.tar.bz2</A><BR>
					 (size:&nbsp; 1.7M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/ro.messages.bz2">i18n.kde.org/po_overview/ro.messages.bz2</A><BR>
					 (size:&nbsp; 422k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/ro-highscore.html">i18n.kde.org/stats/gui/ro-highscore.html</A></LI>
				  
				  <LI>doc statistics: <A
					 HREF="../stats/doc/html/doc-ro.html">i18n.kde.org/stats/doc/html/doc-ro.html</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- Russian -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="ru">ru</A></TH> 
			 <TH ALIGN="LEFT">Russian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:mokhin@bog.msu.ru">Gregory
					 Mokhin</A></LI> 
				  <LI>mailing list: subscribe by visiting:
					 <A
					  HREF="http://maillist.mscom.ru/mailman/listinfo.cgi/kde-i18n/">maillist.mscom.ru/mailman/listinfo.cgi/kde-i18n/</A>
					 or by sending "subscribe" to
					 <A
					  HREF="mailto:kde-i18n-request@maillist.mscom.ru">kde-i18n-request@maillist.mscom.ru</A>.
					 Archives are available at
					 <A
					  HREF="http://maillist.mscom.ru/pipermail/kde-i18n/">maillist.mscom.ru/pipermail/kde-i18n/</A><A
					 HREF="http://maillist.mscom.ru/pipermail.cgi/kde-i18n"></A></LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-ru.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-ru.tar.bz2</A><BR>
					 (size:&nbsp; 2.3M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/ru.messages.bz2">i18n.kde.org/po_overview/ru.messages.bz2</A><BR>
					 (size:&nbsp; 696k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/ru-highscore.html">i18n.kde.org/stats/gui/ru-highscore.html</A></LI>
				  
				  <LI>doc statistics:
					 <A
					  HREF="http://i18n.kde.org/stats/doc/index.php?team=ru">http://i18n.kde.org/stats/doc/index.php?team=ru</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- Slovak -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="sk">sk</A></TH> 
			 <TH ALIGN="LEFT">Slovak team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:bednar@isternet.sk">Juraj
					 Bednar</A></LI> 
				  <LI>mailing list: subscribe via:
					 <A
					  HREF="http://rak.isternet.sk/mailman/listinfo/sk-i18n/">rak.isternet.sk/mailman/listinfo/sk-i18n</A>
					 or by sending "subscribe" to <A
					 HREF="mailto:sk-i18n-request@rak.isternet.sk">sk-i18n-request@rak.isternet.sk</A>.
					 Archives are available at <A
					 HREF="http://rak.isternet.sk/pipermail/sk-i18n/">rak.isternet.sk/pipermail/sk-i18n</A>.</LI>
				  
				  <LI>web site: <A
					 HREF="http://ski18n.linux.sk/">ski18n.linux.sk</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-sk.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-sk.tar.bz2</A><BR>
					 (size:&nbsp; 3.7M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/sk.messages.bz2">i18n.kde.org/po_overview/sk.messages.bz2</A><BR>
					 (size:&nbsp; 867k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/sk-highscore.html">i18n.kde.org/stats/gui/sk-highscore.html</A></LI>
				  
				  <LI>doc statistics:
					 <A
					  HREF="http://i18n.kde.org/stats/doc/index.php?team=sk">i18n.kde.org/stats/doc/index.php?team=sk</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- Slovenian -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="sl">sl</A></TH> 
			 <TH ALIGN="LEFT">Slovenian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:roman.maurer@amis.net">Roman
					 Maurer</A></LI> 
				  <LI>mailing list:
					 <A HREF="http://www.lugos.si/delo/slo/lugos-slo.html">lugos-slo</A></LI> 
				  <LI>team web site: <A
					 HREF="http://i18n.kde.org/teams/sl/">i18n.kde.org/teams/sl/</A></LI> 
				  <LI>user web site: <A
					 HREF="http://www.lugos.si/delo/slo/KDE-sl/">www.lugos.si/delo/slo/KDE-sl/</A></LI>
				  
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-sl.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-sl.tar.bz2</A><BR>
					 (size:&nbsp; 5.1M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/sl.messages.bz2">i18n.kde.org/po_overview/sl.messages.bz2</A><BR>
					 (size:&nbsp; 1.0M)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/sl-highscore.html">i18n.kde.org/stats/gui/sl-highscore.html</A></LI>
				  
				  <LI>doc statistics:
					 <A
					  HREF="http://i18n.kde.org/stats/doc/index.php?team=sl">i18n.kde.org/stats/doc/index.php?team=sl</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- Serbian -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="sr">sr</A></TH> 
			 <TH ALIGN="LEFT">Serbian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): <A
					 HREF="mailto:roske@mainstream.co.yu">Marko Rosic</A>,
					 <A HREF="mailto:twiddle@EUnet.yu">Slobodan Markovic</A></LI> 
				  <LI>mailing list: send an empty mail to
					 <A HREF="mailto:kde-yu-subscribe@egroups.com">kde-yu-subscribe@egroups.com</A>
					 </LI> 
				  <LI>web site: <A
					 HREF="http://www.kde.org.yu/">www.kde.org.yu</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-sr.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-sr.tar.bz2</A><BR>
					 (size:&nbsp; 1.1M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/sr.messages.bz2">i18n.kde.org/po_overview/sr.messages.bz2</A><BR>
					 (size:&nbsp; 282k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/sr-highscore.html">i18n.kde.org/stats/gui/sr-highscore.html</A></LI>
				  
				  <LI>doc statistics: <A
					 HREF="../stats/doc/html/doc-sr.html">i18n.kde.org/stats/doc/html/doc-sr.html</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- Swedish -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="sv">sv</A></TH> 
			 <TH ALIGN="LEFT">Swedish team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:awl@hem.passagen.se">Anders
					 Widell</A>, <A HREF="mailto:backstrom@kde.org">Karl Backstr&ouml;m</A></LI> 
				  <LI>mailing list:
					 <A
					  HREF="http://lists.lysator.liu.se/mailman/listinfo/swedoc">http://lists.lysator.liu.se/mailman/listinfo/swedoc</A></LI>
				  
				  <LI>web site: <A
					 HREF="http://i18n.kde.org/teams/sv/">i18n.kde.org/teams/sv/</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-sv.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-sv.tar.bz2</A><BR>
					 (size:&nbsp; 4.9M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/sv.messages.bz2">i18n.kde.org/po_overview/sv.messages.bz2</A><BR>
					 (size:&nbsp; 1.4M)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/sv-highscore.html">i18n.kde.org/stats/gui/sv-highscore.html</A></LI>
				  
				  <LI>doc statistics:
					 <A
					  HREF="http://i18n.kde.org/stats/doc/index.php?team=sv&date=2001-08-13">i18n.kde.org/stats/doc/index.php?team=sv&amp;date=2001-08-13</A></LI>
				  
				</UL></TD> 
		  </TR>
<!-- Tamil -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="ta">ta</A></TH> 
			 <TH ALIGN="LEFT">Tamil team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:sshanmu@yahoo.com">Sivakumar
					 Shanmugasundaram</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: <A
					 HREF="http://www.tamillinux.org/">www.tamillinux.org</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-ta.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-ta.tar.bz2</A><BR>
					 (size:&nbsp; 1.0M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/ta.messages.bz2">i18n.kde.org/po_overview/ta.messages.bz2</A><BR>
					 (size:&nbsp; 293k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/ta-highscore.html">i18n.kde.org/stats/gui/ta-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Tajik -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="tg">tg</A></TH> 
			 <TH ALIGN="LEFT">Tajik team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s):
					 <A HREF="mailto:rkovacs@khujandcomptech.dyn.tj">Roger Kovacs</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: <A
					 HREF="http://www.khujandcomptech.dyn.tj/">www.khujandcomptech.dyn.tj</A></LI> 
				  <LI>.po and doc archive:--</LI> 
				  <LI>.po messages translated: --</LI> 
				  <LI>.po files in need of a revision: --</LI> 
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR> 
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="th">th</A></TH> 
			 <TH ALIGN="LEFT">Thai team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:oneall1@yahoo.com">Thaweesak
					 Taekratok</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: --</LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-th.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-th.tar.bz2</A><BR>
					 (size:&nbsp; 1.1M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/th.messages.bz2">i18n.kde.org/po_overview/th.messages.bz2</A><BR>
					 (size:&nbsp;   1k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/th-highscore.html">i18n.kde.org/stats/gui/th-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Turkish -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="tr">tr</A></TH> 
			 <TH ALIGN="LEFT">Turkish team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:gorkem@gelecek.com.tr">Gorkem
					 Cetin</A></LI> 
				  <LI>mailing list: kde-i18n-tr@kde.org (to get in send mail with
					 "subscribe" in the subject line to <A
					 HREF="mailto:kde-i18n-tr-request@kde.org">kde-i18n-tr-request@kde.org</A>)</LI>
				  
				  <LI>web site: <A HREF="tr/">www.tr.i18n.kde.org</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-tr.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-tr.tar.bz2</A><BR>
					 (size:&nbsp; 1.7M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/tr.messages.bz2">i18n.kde.org/po_overview/tr.messages.bz2</A><BR>
					 (size:&nbsp;[an error occurred while processing this directive])</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/tr-highscore.html">i18n.kde.org/stats/gui/tr-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Ukrainian -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="uk">uk</A></TH> 
			 <TH ALIGN="LEFT">Ukrainian team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:mike@LITech.lviv.ua">Mike
					 Futerko</A>, <A HREF="mailto:arysin@yahoo.com">Andy Rysin</A></LI> 
				  <LI>mailing list: linux@linux.org.ua (to get in send mail with
					 "subscribe linux your_address" to <A
					 HREF="mailto:majordomo@linux.org.ua">majordomo@linux.org.ua</A>)</LI> 
				  <LI>web site: <A
					 HREF="http://kde.alphadiz.com/">kde.alphadiz.com</A><A
					 HREF="http://dict.linux.org.ua/kde2/"></A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-uk.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-uk.tar.bz2</A><BR>
					 (size:&nbsp; 1.4M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/uk.messages.bz2">i18n.kde.org/po_overview/uk.messages.bz2</A><BR>
					 (size:&nbsp;[an error occurred while processing this directive])</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/uk-highscore.html">i18n.kde.org/stats/gui/uk-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Vietnamese -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="uk">vi</A></TH> 
			 <TH ALIGN="LEFT">Vietnamese team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): <A HREF="mailto:hung@vnlinux.org">Nguyen
					 Hung.Vu</A></LI> 
				  <LI>mailing list: to subcribe send email to:
					 <A
					  HREF="mailto:KDE-i18n-VN-subscribe@yahoogroups.com">KDE-i18n-VN-subscribe@yahoogroups.com</A><BR>to
					 unsubscribe send email to: KDE-i18n-VN-unsubscribe@yahoogroups.com<BR>to post a
					 message send email to: KDE-i18n-VN@yahoogroups.com</LI> 
				  <LI>web site:
					 <A
					  HREF="http://groups.yahoo.com/group/KDE-i18n-VN/">groups.yahoo.com/group/KDE-i18n-VN</A></LI>
				  
				  <LI>.po and doc archive: --</LI> 
				  <LI>.po messages translated: --</LI> 
				  <LI>.po files in need of a revision: --</LI> 
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Walloon -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="wa">wa</A></TH> 
			 <TH ALIGN="LEFT">Walloon team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinators: <B>unmaintained</B> (former maintainer:
					 <A HREF="mailto:LorintHendschel@skynet.be">Lorint Hendschel</A>)</LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: <A
					 HREF="http://users.skynet.be/bs302306/linux/">users.skynet.be/bs302306/linux/</A></LI>
				  
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-wa.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-wa.tar.bz2</A><BR>
					 (size:&nbsp; 471k)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/wa.messages.bz2">i18n.kde.org/po_overview/wa.messages.bz2</A><BR>
					 (size:&nbsp;[an error occurred while processing this directive])</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/wa-highscore.html">i18n.kde.org/stats/gui/wa-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Xhosa -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="zh_CN.GB2312">xh</A></TH> 
			 <TH ALIGN="LEFT">Xhosa team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>team coordinator(s): <A
					 HREF="mailto:dwayne@translate.org.za">Dwayne Bailey</A></LI> 
				  <LI>mailing list: --</LI> 
				  <LI>web site: <A
					 HREF="http://translate.org.za/">translate.org.za</A></LI> 
				  <LI>.po and doc archive: --</LI> 
				  <LI>.po messages translated: --</LI> 
				  <LI>.po files in need of a revision: --</LI> 
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Simplified Chinese -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="zh_CN.GB2312">zh_CN.GB2312</A></TH> 
			 <TH ALIGN="LEFT">Simplified Chinese team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A HREF="mailto:lark@linux.net.cn">Wang
					 Jian</A></LI> 
				  <LI>mailing list: i18n-translation@lists.linux.net.cn (for
					 subscription send email with body set to one line "subscribe i18n-translation"
					 <A HREF="mailto:sympa@lists.linux.net.cn">sympa@lists.linux.net.cn</A> or visit
					 <A
					  HREF="http://lists.linux.net.cn/wws/subscribe/i18n-translation/">lists.linux.net.cn/wws/subscribe/i18n-translation</A>)</LI>
				  
				  <LI>web site: <A
					 HREF="http://i18n.linux.net.cn/">i18n.linux.net.cn</A></LI> 
				  <LI>.po and doc archive:
					 <A
					  HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-zh_CN.GB2312.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-zh_CN.GB2312.tar.bz2</A><BR>
					 (size:&nbsp; 1.3M)</LI> 
				  <LI>.po messages translated:
					 <A
					  HREF="../po_overview/zh_CN.GB2312.messages.bz2">i18n.kde.org/po_overview/zh_CN.GB2312.messages.bz2</A><BR>
					 (size:&nbsp; 326k)</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/zh_CN.GB2312-highscore.html">i18n.kde.org/stats/gui/zh_CN.GB2312-highscore.html</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR>
<!-- Chinese BIG5 -->
		  <TR BGCOLOR="#C8C8FF"> 
			 <TH ALIGN="LEFT"><A NAME="zh_TW.Big5">zh_TW.Big5</A></TH> 
			 <TH ALIGN="LEFT">Traditional Chinese team</TH> 
		  </TR> 
		  <TR> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF">&nbsp;</TD> 
			 <TD ALIGN="LEFT" BGCOLOR="#F0F0FF"> 
				<UL TYPE="SQUARE"> 
				  <LI>coordinator(s): <A
					 HREF="mailto:kenduest@i18n.linux.org.tw">Kenduest Lee</A></LI> 
				  <LI>mailing list: zh-l10n@linux.org.tw (Send email to
					 <A HREF="mailto:majordomo@linux.org.tw">majordomo@linux.org.tw</A> with mail
					 body "subscribe zh-l10n")</LI> 
				  <LI>web site: <A
					 HREF="http://i18n.linux.org.tw/">i18n.linux.org.tw</A></LI> 
				  <LI>.po and doc archive:
					 <A HREF="ftp://ftp.kde.org/pub/kde/snapshots/current/kde-i18n/kde-i18n-zh_T
W.Big5.tar.bz2">i18n.kde.org/translation_archive/kde-i18n-
					 zh_TW.Big5.tar.bz2</A><BR> (size:&nbsp; 1.7M)</LI> 
				  <LI>.po messages translated:
					 <A HREF="../po_overview/zh_TW_Big5.messages.bz2">i18n.kde.org/po_overview/zh_TW
					 .Big5.messages.bz2</A><BR> (size:&nbsp;[an error occurred while processing this directive])</LI> 
				  <LI>.po files in need of a revision:
					 <A
					  HREF="../stats/gui/zh_TW.Big5-highscore.html">i18n.kde.org/stats/gui/zh_TW.Big5-highscore</A></LI>
				  
				  <LI>doc statistics: --</LI> 
				</UL></TD> 
		  </TR> 
		</TABLE></CENTER> 
	 <CENTER> <HR> <FONT SIZE="-1">Page maintained by
		<A HREF="mailto:thd@kde.org">Thomas Diehl</A>. Last update 11 Oktober
		2001</FONT></CENTER> </BODY>
</HTML>
