diff --git a/res/xml-cs/timezones.xml b/res/xml-cs/timezones.xml
new file mode 100644
index 0000000..a02d0d2
--- /dev/null
+++ b/res/xml-cs/timezones.xml
@@ -0,0 +1,84 @@
+<timezones>
+    <timezone id="Pacific/Majuro">Majuro</timezone>
+    <timezone id="Pacific/Midway">Midway</timezone>
+    <timezone id="Pacific/Honolulu">Honolulu</timezone>
+    <timezone id="America/Anchorage">Aljašský čas</timezone>
+    <timezone id="America/Los_Angeles">Pacifický standardní čas (Los Angeles)</timezone>
+    <timezone id="America/Tijuana">Pacifický standardní čas (Tichuana)</timezone>
+    <timezone id="America/Phoenix">Horský standardní čas (Phoenix)</timezone>
+    <timezone id="America/Chihuahua">Chihuahua</timezone>
+    <timezone id="America/Denver">Horský standardní čas (Denver)</timezone>
+    <timezone id="America/Costa_Rica">Centrální standardní čas (Kostarika)</timezone>
+    <timezone id="America/Chicago">Centrální standardní čas (Chicago)</timezone>
+    <timezone id="America/Mexico_City">Centrální standardní čas (Mexico City)</timezone>
+    <timezone id="America/Regina">Centrální standardní čas (Regina)</timezone>
+    <timezone id="America/Bogota">Bogota</timezone>
+    <timezone id="America/New_York">New York</timezone>
+    <timezone id="America/Caracas">Caracas</timezone>
+    <timezone id="America/Barbados">Atlantický standardní čas (Barbados)</timezone>
+    <timezone id="America/Manaus">Manaus</timezone>
+    <timezone id="America/Santiago">Santiago</timezone>
+    <timezone id="America/St_Johns">Newfoundlandský standardní čas (St. Johns)</timezone>
+    <timezone id="America/Araguaina">Araguaina</timezone>
+    <timezone id="America/Argentina/Buenos_Aires">Buenos Aires</timezone>
+    <timezone id="America/Godthab">Godthab</timezone>
+    <timezone id="America/Montevideo">Montevideo</timezone>
+    <timezone id="Atlantic/South_Georgia">Jižní Georgia</timezone>
+    <timezone id="Atlantic/Azores">Azorské ostrovy</timezone>
+    <timezone id="Atlantic/Cape_Verde">Kapverdy</timezone>
+    <timezone id="Africa/Casablanca">Casablanca</timezone>
+    <timezone id="Europe/London">Greenwichský střední čas (Londýn)</timezone>
+    <timezone id="Europe/Amsterdam">Středoevropský standardní čas (Amsterdam)</timezone>
+    <timezone id="Europe/Belgrade">Středoevropský standardní čas (Belgrade)</timezone>
+    <timezone id="Europe/Brussels">Středoevropský standardní čas (Brusel)</timezone>
+    <timezone id="Europe/Sarajevo">Středoevropský standardní čas (Sarajevo)</timezone>
+    <timezone id="Africa/Windhoek">Windhoek</timezone>
+    <timezone id="Africa/Brazzaville">Brazzaville</timezone>
+    <timezone id="Asia/Amman">Východoevropský standardní čas (Ammán)</timezone>
+    <timezone id="Europe/Athens">Východoevropský standardní čas (Atény)</timezone>
+    <timezone id="Asia/Beirut">Východoevropský standardní čas (Bejrút)</timezone>
+    <timezone id="Africa/Cairo">Východoevropský standardní čas (Káhira)</timezone>
+    <timezone id="Europe/Helsinki">Východoevropský standardní čas (Helsinki)</timezone>
+    <timezone id="Asia/Jerusalem">Izraelský standardní čas (Jeruzalém)</timezone>
+    <timezone id="Europe/Minsk">Minsk</timezone>
+    <timezone id="Africa/Harare">Harare</timezone>
+    <timezone id="Asia/Baghdad">Bagdád</timezone>
+    <timezone id="Europe/Moscow">Moskva</timezone>
+    <timezone id="Asia/Kuwait">Kuvajt</timezone>
+    <timezone id="Africa/Nairobi">Nairobi</timezone>
+    <timezone id="Asia/Tehran">Teherán</timezone>
+    <timezone id="Asia/Baku">Baku</timezone>
+    <timezone id="Asia/Tbilisi">Tbilisi</timezone>
+    <timezone id="Asia/Yerevan">Jerevan</timezone>
+    <timezone id="Asia/Dubai">Dubaj</timezone>
+    <timezone id="Asia/Kabul">Kábul</timezone>
+    <timezone id="Asia/Karachi">Karáčí</timezone>
+    <timezone id="Asia/Oral">Oral</timezone>
+    <timezone id="Asia/Yekaterinburg">Jekatěrinburg</timezone>
+    <timezone id="Asia/Calcutta">Calcutta</timezone>
+    <timezone id="Asia/Colombo">Colombo</timezone>
+    <timezone id="Asia/Katmandu">Katmandu</timezone>
+    <timezone id="Asia/Almaty">Almaty</timezone>
+    <timezone id="Asia/Rangoon">Rangún</timezone>
+    <timezone id="Asia/Krasnoyarsk">Krasnojarsk</timezone>
+    <timezone id="Asia/Bangkok">Bangkok</timezone>
+    <timezone id="Asia/Hong_Kong">Hong Kong</timezone>
+    <timezone id="Asia/Irkutsk">Irkutsk</timezone>
+    <timezone id="Asia/Kuala_Lumpur">Kuala Lumpur</timezone>
+    <timezone id="Australia/Perth">Perth</timezone>
+    <timezone id="Asia/Taipei">Čínský standardní čas (Taipei)</timezone>
+    <timezone id="Asia/Seoul">Soul</timezone>
+    <timezone id="Asia/Tokyo">Japonský standardní čas (Tokio)</timezone>
+    <timezone id="Asia/Yakutsk">Jakutsk</timezone>
+    <timezone id="Australia/Adelaide">Adelaide</timezone>
+    <timezone id="Australia/Darwin">Darwin</timezone>
+    <timezone id="Australia/Brisbane">Brisbane</timezone>
+    <timezone id="Australia/Hobart">Hobart</timezone>
+    <timezone id="Australia/Sydney">Sydney</timezone>
+    <timezone id="Asia/Vladivostok">Vladivostok</timezone>
+    <timezone id="Pacific/Guam">Guam</timezone>
+    <timezone id="Asia/Magadan">Magadan</timezone>
+    <timezone id="Pacific/Auckland">Auckland</timezone>
+    <timezone id="Pacific/Fiji">Fidži</timezone>
+    <timezone id="Pacific/Tongatapu">Tongatapu</timezone>
+</timezones>
diff --git a/res/xml-de/timezones.xml b/res/xml-de/timezones.xml
new file mode 100644
index 0000000..39bedfe
--- /dev/null
+++ b/res/xml-de/timezones.xml
@@ -0,0 +1,84 @@
+<timezones>
+    <timezone id="Pacific/Majuro">Majuro</timezone>
+    <timezone id="Pacific/Midway">Midway</timezone>
+    <timezone id="Pacific/Honolulu">Honolulu</timezone>
+    <timezone id="America/Anchorage">Anchorage</timezone>
+    <timezone id="America/Los_Angeles">Los Angeles</timezone>
+    <timezone id="America/Tijuana">Tijuana</timezone>
+    <timezone id="America/Phoenix">Phoenix</timezone>
+    <timezone id="America/Chihuahua">Chihuahua</timezone>
+    <timezone id="America/Denver">Denver</timezone>
+    <timezone id="America/Costa_Rica">Costa Rica</timezone>
+    <timezone id="America/Chicago">Chicago</timezone>
+    <timezone id="America/Mexico_City">Mexiko-Stadt</timezone>
+    <timezone id="America/Regina">Regina</timezone>
+    <timezone id="America/Bogota">Bogota</timezone>
+    <timezone id="America/New_York">New York</timezone>
+    <timezone id="America/Caracas">Caracas</timezone>
+    <timezone id="America/Barbados">Barbados</timezone>
+    <timezone id="America/Manaus">Manaus</timezone>
+    <timezone id="America/Santiago">Santiago</timezone>
+    <timezone id="America/St_Johns">St. John's</timezone>
+    <timezone id="America/Araguaina">Araguaina</timezone>
+    <timezone id="America/Argentina/Buenos_Aires">Buenos Aires</timezone>
+    <timezone id="America/Godthab">Godthab</timezone>
+    <timezone id="America/Montevideo">Montevideo</timezone>
+    <timezone id="Atlantic/South_Georgia">Süd-Georgien</timezone>
+    <timezone id="Atlantic/Azores">Azoren</timezone>
+    <timezone id="Atlantic/Cape_Verde">Kap Verde</timezone>
+    <timezone id="Africa/Casablanca">Casablanca</timezone>
+    <timezone id="Europe/London">London</timezone>
+    <timezone id="Europe/Amsterdam">Mitteleuropäische Zeit (Amsterdam)</timezone>
+    <timezone id="Europe/Belgrade">Mitteleuropäische Zeit (Belgrade)</timezone>
+    <timezone id="Europe/Brussels">Mitteleuropäische Zeit (Brüssel)</timezone>
+    <timezone id="Europe/Sarajevo">Mitteleuropäische Zeit (Sarajevo)</timezone>
+    <timezone id="Africa/Windhoek">Windhoek</timezone>
+    <timezone id="Africa/Brazzaville">Westafrikanische Zeit (Brazzaville)</timezone>
+    <timezone id="Asia/Amman">Osteuropäische Zeit (Amman)</timezone>
+    <timezone id="Europe/Athens">Osteuropäische Zeit (Athen)</timezone>
+    <timezone id="Asia/Beirut">Osteuropäische Zeit (Beirut)</timezone>
+    <timezone id="Africa/Cairo">Osteuropäische Zeit (Kairo)</timezone>
+    <timezone id="Europe/Helsinki">Osteuropäische Zeit (Helsinki)</timezone>
+    <timezone id="Asia/Jerusalem">Jerusalem</timezone>
+    <timezone id="Europe/Minsk">Minsk</timezone>
+    <timezone id="Africa/Harare">Zentralafrikanische Zeit (Harare)</timezone>
+    <timezone id="Asia/Baghdad">Bagdad</timezone>
+    <timezone id="Europe/Moscow">Moskau</timezone>
+    <timezone id="Asia/Kuwait">Kuwait</timezone>
+    <timezone id="Africa/Nairobi">Ostafrikanische Zeit (Nairobi)</timezone>
+    <timezone id="Asia/Tehran">Teheran</timezone>
+    <timezone id="Asia/Baku">Baku</timezone>
+    <timezone id="Asia/Tbilisi">Tiflis</timezone>
+    <timezone id="Asia/Yerevan">Erivan</timezone>
+    <timezone id="Asia/Dubai">Dubai</timezone>
+    <timezone id="Asia/Kabul">Afghanistan-Zeit (Kabul)</timezone>
+    <timezone id="Asia/Karachi">Karachi</timezone>
+    <timezone id="Asia/Oral">Oral</timezone>
+    <timezone id="Asia/Yekaterinburg">Jekaterinburg</timezone>
+    <timezone id="Asia/Calcutta">Calcutta</timezone>
+    <timezone id="Asia/Colombo">Colombo</timezone>
+    <timezone id="Asia/Katmandu">Katmandu</timezone>
+    <timezone id="Asia/Almaty">Almaty</timezone>
+    <timezone id="Asia/Rangoon">Rangoon</timezone>
+    <timezone id="Asia/Krasnoyarsk">Krasnojarsk</timezone>
+    <timezone id="Asia/Bangkok">Bangkok</timezone>
+    <timezone id="Asia/Hong_Kong">Hongkong</timezone>
+    <timezone id="Asia/Irkutsk">Irkutsk</timezone>
+    <timezone id="Asia/Kuala_Lumpur">Kuala Lumpur</timezone>
+    <timezone id="Australia/Perth">Perth</timezone>
+    <timezone id="Asia/Taipei">Taipeh</timezone>
+    <timezone id="Asia/Seoul">Seoul</timezone>
+    <timezone id="Asia/Tokyo">Tokio</timezone>
+    <timezone id="Asia/Yakutsk">Jakutsk</timezone>
+    <timezone id="Australia/Adelaide">Adelaide</timezone>
+    <timezone id="Australia/Darwin">Darwin</timezone>
+    <timezone id="Australia/Brisbane">Brisbane</timezone>
+    <timezone id="Australia/Hobart">Hobart</timezone>
+    <timezone id="Australia/Sydney">Sydney</timezone>
+    <timezone id="Asia/Vladivostok">Wladiwostok</timezone>
+    <timezone id="Pacific/Guam">Guam</timezone>
+    <timezone id="Asia/Magadan">Magadan</timezone>
+    <timezone id="Pacific/Auckland">Auckland</timezone>
+    <timezone id="Pacific/Fiji">Fidschi</timezone>
+    <timezone id="Pacific/Tongatapu">Tongatapu</timezone>
+</timezones>
diff --git a/res/xml-es/timezones.xml b/res/xml-es/timezones.xml
new file mode 100644
index 0000000..674d55d
--- /dev/null
+++ b/res/xml-es/timezones.xml
@@ -0,0 +1,84 @@
+<timezones>
+    <timezone id="Pacific/Majuro">Majuro</timezone>
+    <timezone id="Pacific/Midway">Midway</timezone>
+    <timezone id="Pacific/Honolulu">Honolulú</timezone>
+    <timezone id="America/Anchorage">Anchorage</timezone>
+    <timezone id="America/Los_Angeles">Hora estándar del Pacífico (Los Ángeles)</timezone>
+    <timezone id="America/Tijuana">Hora estándar del Pacífico (Hora de México (Tijuana))</timezone>
+    <timezone id="America/Phoenix">Hora estándar de Montaña (Hora de Estados Unidos (Phoenix))</timezone>
+    <timezone id="America/Chihuahua">Hora de México (Chihuahua)</timezone>
+    <timezone id="America/Denver">Hora estándar de Montaña (Denver)</timezone>
+    <timezone id="America/Costa_Rica">Hora central (Costa Rica)</timezone>
+    <timezone id="America/Chicago">Hora central (Chicago)</timezone>
+    <timezone id="America/Mexico_City">Hora central (Ciudad de México)</timezone>
+    <timezone id="America/Regina">Hora central (Hora de Canadá (Regina))</timezone>
+    <timezone id="America/Bogota">Bogotá</timezone>
+    <timezone id="America/New_York">Hora oriental (Nueva York)</timezone>
+    <timezone id="America/Caracas">Caracas</timezone>
+    <timezone id="America/Barbados">Hora estándar del Atlántico (Barbados)</timezone>
+    <timezone id="America/Manaus">Manaus</timezone>
+    <timezone id="America/Santiago">Santiago</timezone>
+    <timezone id="America/St_Johns">Hora estándar de Newfoundland (St. Johns)</timezone>
+    <timezone id="America/Araguaina">Araguaína</timezone>
+    <timezone id="America/Argentina/Buenos_Aires">Hora de Argentina (Buenos Aires)</timezone>
+    <timezone id="America/Godthab">Godthab</timezone>
+    <timezone id="America/Montevideo">Montevideo</timezone>
+    <timezone id="Atlantic/South_Georgia">Georgia del Sur</timezone>
+    <timezone id="Atlantic/Azores">Azores</timezone>
+    <timezone id="Atlantic/Cape_Verde">Cabo Verde</timezone>
+    <timezone id="Africa/Casablanca">Casablanca</timezone>
+    <timezone id="Europe/London">Hora media de Greenwich (Londres)</timezone>
+    <timezone id="Europe/Amsterdam">Hora estándar de Europa Central (Amsterdam)</timezone>
+    <timezone id="Europe/Belgrade">Hora estándar de Europa Central (Belgrade)</timezone>
+    <timezone id="Europe/Brussels">Hora estándar de Europa Central (Bruselas)</timezone>
+    <timezone id="Europe/Sarajevo">Hora estándar de Europa Central (Sarajevo)</timezone>
+    <timezone id="Africa/Windhoek">Windhoek</timezone>
+    <timezone id="Africa/Brazzaville">Brazzaville</timezone>
+    <timezone id="Asia/Amman">Hora estándar de Europa del Este (Amman)</timezone>
+    <timezone id="Europe/Athens">Hora estándar de Europa del Este (Atenas)</timezone>
+    <timezone id="Asia/Beirut">Hora estándar de Europa del Este (Beirut)</timezone>
+    <timezone id="Africa/Cairo">Hora estándar de Europa del Este (El Cairo)</timezone>
+    <timezone id="Europe/Helsinki">Hora estándar de Europa del Este (Helsinki)</timezone>
+    <timezone id="Asia/Jerusalem">Hora estándar de Israel (Jerusalén)</timezone>
+    <timezone id="Europe/Minsk">Minsk</timezone>
+    <timezone id="Africa/Harare">Harare</timezone>
+    <timezone id="Asia/Baghdad">Bagdad</timezone>
+    <timezone id="Europe/Moscow">Moscú</timezone>
+    <timezone id="Asia/Kuwait">Kuwait</timezone>
+    <timezone id="Africa/Nairobi">Nairobi</timezone>
+    <timezone id="Asia/Tehran">Teherán</timezone>
+    <timezone id="Asia/Baku">Bakú</timezone>
+    <timezone id="Asia/Tbilisi">Tiflis</timezone>
+    <timezone id="Asia/Yerevan">Ereván</timezone>
+    <timezone id="Asia/Dubai">Dubai</timezone>
+    <timezone id="Asia/Kabul">Kabul</timezone>
+    <timezone id="Asia/Karachi">Karachi</timezone>
+    <timezone id="Asia/Oral">Oral</timezone>
+    <timezone id="Asia/Yekaterinburg">Yekaterinburgo</timezone>
+    <timezone id="Asia/Calcutta">Calcutta</timezone>
+    <timezone id="Asia/Colombo">Colombo</timezone>
+    <timezone id="Asia/Katmandu">Katmandú</timezone>
+    <timezone id="Asia/Almaty">Almaty</timezone>
+    <timezone id="Asia/Rangoon">Rangún</timezone>
+    <timezone id="Asia/Krasnoyarsk">Krasnoyarsk</timezone>
+    <timezone id="Asia/Bangkok">Bangkok</timezone>
+    <timezone id="Asia/Hong_Kong">Hong Kong</timezone>
+    <timezone id="Asia/Irkutsk">Irkutsk</timezone>
+    <timezone id="Asia/Kuala_Lumpur">Kuala Lumpur</timezone>
+    <timezone id="Australia/Perth">Hora de Australia (Perth)</timezone>
+    <timezone id="Asia/Taipei">Hora estándar de China (Taipei)</timezone>
+    <timezone id="Asia/Seoul">Seúl</timezone>
+    <timezone id="Asia/Tokyo">Hora estándar de Japón (Tokio)</timezone>
+    <timezone id="Asia/Yakutsk">Yakutsk</timezone>
+    <timezone id="Australia/Adelaide">Adelaida</timezone>
+    <timezone id="Australia/Darwin">Hora de Australia (Darwin)</timezone>
+    <timezone id="Australia/Brisbane">Hora de Australia (Brisbane)</timezone>
+    <timezone id="Australia/Hobart">Hora de Australia (Hobart)</timezone>
+    <timezone id="Australia/Sydney">Sydney</timezone>
+    <timezone id="Asia/Vladivostok">Vladivostok</timezone>
+    <timezone id="Pacific/Guam">Guam</timezone>
+    <timezone id="Asia/Magadan">Magadan</timezone>
+    <timezone id="Pacific/Auckland">Auckland</timezone>
+    <timezone id="Pacific/Fiji">Fiyi</timezone>
+    <timezone id="Pacific/Tongatapu">Tongatapu</timezone>
+</timezones>
diff --git a/res/xml-fr/timezones.xml b/res/xml-fr/timezones.xml
new file mode 100644
index 0000000..9967382
--- /dev/null
+++ b/res/xml-fr/timezones.xml
@@ -0,0 +1,84 @@
+<timezones>
+    <timezone id="Pacific/Majuro">Majuro</timezone>
+    <timezone id="Pacific/Midway">Midway</timezone>
+    <timezone id="Pacific/Honolulu">Honolulu</timezone>
+    <timezone id="America/Anchorage">Anchorage</timezone>
+    <timezone id="America/Los_Angeles">Heure du Pacifique (Los Angeles)</timezone>
+    <timezone id="America/Tijuana">Heure du Pacifique (Tijuana)</timezone>
+    <timezone id="America/Phoenix">Heure des Rocheuses (Phoenix)</timezone>
+    <timezone id="America/Chihuahua">Chihuahua</timezone>
+    <timezone id="America/Denver">Heure des Rocheuses (Denver)</timezone>
+    <timezone id="America/Costa_Rica">Heure du Centre (San José)</timezone>
+    <timezone id="America/Chicago">Heure du Centre (Chicago)</timezone>
+    <timezone id="America/Mexico_City">Heure du Centre (Mexico)</timezone>
+    <timezone id="America/Regina">Heure du Centre (Regina)</timezone>
+    <timezone id="America/Bogota">Bogota</timezone>
+    <timezone id="America/New_York">Heure de l’Est (New York)</timezone>
+    <timezone id="America/Caracas">Caracas</timezone>
+    <timezone id="America/Barbados">Heure de l’Atlantique (Barbade (La))</timezone>
+    <timezone id="America/Manaus">Manaus</timezone>
+    <timezone id="America/Santiago">Santiago</timezone>
+    <timezone id="America/St_Johns">Heure de Terre-Neuve (Saint-Jean de Terre-Neuve)</timezone>
+    <timezone id="America/Araguaina">Araguaína</timezone>
+    <timezone id="America/Argentina/Buenos_Aires">Heure d’Argentine (Buenos Aires)</timezone>
+    <timezone id="America/Godthab">Heure de l’Ouest du Groenland (Godthåb)</timezone>
+    <timezone id="America/Montevideo">Montevideo</timezone>
+    <timezone id="Atlantic/South_Georgia">Heure de Géorgie du Sud (Géorgie du Sud)</timezone>
+    <timezone id="Atlantic/Azores">Ponta Delgada</timezone>
+    <timezone id="Atlantic/Cape_Verde">Cap Vert</timezone>
+    <timezone id="Africa/Casablanca">Casablanca</timezone>
+    <timezone id="Europe/London">Heure moyenne de Greenwich (Londres)</timezone>
+    <timezone id="Europe/Amsterdam">Heure de l’Europe centrale (Amsterdam)</timezone>
+    <timezone id="Europe/Belgrade">Heure de l’Europe centrale (Belgrade)</timezone>
+    <timezone id="Europe/Brussels">Heure de l’Europe centrale (Bruxelles)</timezone>
+    <timezone id="Europe/Sarajevo">Heure de l’Europe centrale (Sarajevo)</timezone>
+    <timezone id="Africa/Windhoek">Windhoek</timezone>
+    <timezone id="Africa/Brazzaville">Heure normale d’Afrique de l’Ouest (Brazzaville)</timezone>
+    <timezone id="Asia/Amman">Heure normale de l’Europe de l’Est (Amman)</timezone>
+    <timezone id="Europe/Athens">Heure normale de l’Europe de l’Est (Athènes)</timezone>
+    <timezone id="Asia/Beirut">Heure normale de l’Europe de l’Est (Beyrouth)</timezone>
+    <timezone id="Africa/Cairo">Heure normale de l’Europe de l’Est (Le Caire)</timezone>
+    <timezone id="Europe/Helsinki">Heure normale de l’Europe de l’Est (Helsinki)</timezone>
+    <timezone id="Asia/Jerusalem">Heure d’Israël (Jérusalem)</timezone>
+    <timezone id="Europe/Minsk">Minsk</timezone>
+    <timezone id="Africa/Harare">Heure normale d’Afrique centrale (Harare)</timezone>
+    <timezone id="Asia/Baghdad">Heure de l’Arabie (Bagdad)</timezone>
+    <timezone id="Europe/Moscow">Moscou</timezone>
+    <timezone id="Asia/Kuwait">Heure de l’Arabie (Koweït)</timezone>
+    <timezone id="Africa/Nairobi">Heure normale d’Afrique de l’Est (Nairobi)</timezone>
+    <timezone id="Asia/Tehran">Heure normale d’Iran (Téhéran)</timezone>
+    <timezone id="Asia/Baku">Bakou</timezone>
+    <timezone id="Asia/Tbilisi">Tbilissi</timezone>
+    <timezone id="Asia/Yerevan">Erevan</timezone>
+    <timezone id="Asia/Dubai">Heure du Golfe (Dubaï)</timezone>
+    <timezone id="Asia/Kabul">Heure d’Afghanistan (Kaboul)</timezone>
+    <timezone id="Asia/Karachi">Karâchi</timezone>
+    <timezone id="Asia/Oral">Oral</timezone>
+    <timezone id="Asia/Yekaterinburg">Iekaterinbourg</timezone>
+    <timezone id="Asia/Calcutta">Heure normale de l’Inde (Kolkata)</timezone>
+    <timezone id="Asia/Colombo">Colombo</timezone>
+    <timezone id="Asia/Katmandu">Katmandou</timezone>
+    <timezone id="Asia/Almaty">Almaty</timezone>
+    <timezone id="Asia/Rangoon">Rangoon</timezone>
+    <timezone id="Asia/Krasnoyarsk">Heure de Krasnoïarsk (Krasnoïarsk)</timezone>
+    <timezone id="Asia/Bangkok">Heure d’Indochine (Bangkok)</timezone>
+    <timezone id="Asia/Hong_Kong">Heure de Hong Kong (Hong-Kong)</timezone>
+    <timezone id="Asia/Irkutsk">Heure d’Irkoutsk (Irkoutsk)</timezone>
+    <timezone id="Asia/Kuala_Lumpur">Kuala Lumpur</timezone>
+    <timezone id="Australia/Perth">Heure de l’Ouest australien (Perth)</timezone>
+    <timezone id="Asia/Taipei">Heure de Chine (Taipei)</timezone>
+    <timezone id="Asia/Seoul">Heure de Corée (Séoul)</timezone>
+    <timezone id="Asia/Tokyo">Heure du Japon (Tokyo)</timezone>
+    <timezone id="Asia/Yakutsk">Iakoutsk</timezone>
+    <timezone id="Australia/Adelaide">Heure du Centre australien (Adélaïde)</timezone>
+    <timezone id="Australia/Darwin">Heure du Centre australien (Darwin)</timezone>
+    <timezone id="Australia/Brisbane">Heure de l’Est australien (Brisbane)</timezone>
+    <timezone id="Australia/Hobart">Heure de l’Est australien (Hobart)</timezone>
+    <timezone id="Australia/Sydney">Heure de l’Est australien (Sydney)</timezone>
+    <timezone id="Asia/Vladivostok">Vladivostok</timezone>
+    <timezone id="Pacific/Guam">Hagåtña</timezone>
+    <timezone id="Asia/Magadan">Magadan</timezone>
+    <timezone id="Pacific/Auckland">Auckland</timezone>
+    <timezone id="Pacific/Fiji">Heure des îles Fidji (Fidji)</timezone>
+    <timezone id="Pacific/Tongatapu">Nukuʻalofa</timezone>
+</timezones>
diff --git a/res/xml-it/timezones.xml b/res/xml-it/timezones.xml
new file mode 100644
index 0000000..5060202
--- /dev/null
+++ b/res/xml-it/timezones.xml
@@ -0,0 +1,84 @@
+<timezones>
+    <timezone id="Pacific/Majuro">Majuro</timezone>
+    <timezone id="Pacific/Midway">Midway</timezone>
+    <timezone id="Pacific/Honolulu">Honolulu</timezone>
+    <timezone id="America/Anchorage">Fuso orario Alaska</timezone>
+    <timezone id="America/Los_Angeles">Los Angeles</timezone>
+    <timezone id="America/Tijuana">Tijuana</timezone>
+    <timezone id="America/Phoenix">Phoenix</timezone>
+    <timezone id="America/Chihuahua">Chihuahua</timezone>
+    <timezone id="America/Denver">Denver</timezone>
+    <timezone id="America/Costa_Rica">Costa Rica</timezone>
+    <timezone id="America/Chicago">Chicago</timezone>
+    <timezone id="America/Mexico_City">Città del Messico</timezone>
+    <timezone id="America/Regina">Regina</timezone>
+    <timezone id="America/Bogota">Bogota</timezone>
+    <timezone id="America/New_York">New York</timezone>
+    <timezone id="America/Caracas">Caracas</timezone>
+    <timezone id="America/Barbados">Barbados</timezone>
+    <timezone id="America/Manaus">Manaus</timezone>
+    <timezone id="America/Santiago">Santiago</timezone>
+    <timezone id="America/St_Johns">St. Johns</timezone>
+    <timezone id="America/Araguaina">Araguaina</timezone>
+    <timezone id="America/Argentina/Buenos_Aires">Buenos Aires</timezone>
+    <timezone id="America/Godthab">Godthab</timezone>
+    <timezone id="America/Montevideo">Montevideo</timezone>
+    <timezone id="Atlantic/South_Georgia">Georgia meridionale</timezone>
+    <timezone id="Atlantic/Azores">Azzorre</timezone>
+    <timezone id="Atlantic/Cape_Verde">Capo Verde</timezone>
+    <timezone id="Africa/Casablanca">Casablanca</timezone>
+    <timezone id="Europe/London">Londra</timezone>
+    <timezone id="Europe/Amsterdam">Ora Standard Europa Centrale (Amsterdam)</timezone>
+    <timezone id="Europe/Belgrade">Ora Standard Europa Centrale (Belgrade)</timezone>
+    <timezone id="Europe/Brussels">Ora Standard Europa Centrale (Bruxelles)</timezone>
+    <timezone id="Europe/Sarajevo">Ora Standard Europa Centrale (Sarajevo)</timezone>
+    <timezone id="Africa/Windhoek">Windhoek</timezone>
+    <timezone id="Africa/Brazzaville">Brazzaville</timezone>
+    <timezone id="Asia/Amman">Ora Standard Europa Orientale (Amman)</timezone>
+    <timezone id="Europe/Athens">Ora Standard Europa Orientale (Atene)</timezone>
+    <timezone id="Asia/Beirut">Ora Standard Europa Orientale (Beirut)</timezone>
+    <timezone id="Africa/Cairo">Ora Standard Europa Orientale (Cairo)</timezone>
+    <timezone id="Europe/Helsinki">Ora Standard Europa Orientale (Helsinki)</timezone>
+    <timezone id="Asia/Jerusalem">Ora Standard Israele (Gerusalemme)</timezone>
+    <timezone id="Europe/Minsk">Minsk</timezone>
+    <timezone id="Africa/Harare">Harare</timezone>
+    <timezone id="Asia/Baghdad">Baghdad</timezone>
+    <timezone id="Europe/Moscow">Mosca</timezone>
+    <timezone id="Asia/Kuwait">Kuwait</timezone>
+    <timezone id="Africa/Nairobi">Nairobi</timezone>
+    <timezone id="Asia/Tehran">Teheran</timezone>
+    <timezone id="Asia/Baku">Baku</timezone>
+    <timezone id="Asia/Tbilisi">Tbilisi</timezone>
+    <timezone id="Asia/Yerevan">Yerevan</timezone>
+    <timezone id="Asia/Dubai">Dubai</timezone>
+    <timezone id="Asia/Kabul">Kabul</timezone>
+    <timezone id="Asia/Karachi">Karachi</timezone>
+    <timezone id="Asia/Oral">Oral</timezone>
+    <timezone id="Asia/Yekaterinburg">Yekaterinburg</timezone>
+    <timezone id="Asia/Calcutta">Calcutta</timezone>
+    <timezone id="Asia/Colombo">Colombo</timezone>
+    <timezone id="Asia/Katmandu">Katmandu</timezone>
+    <timezone id="Asia/Almaty">Almaty</timezone>
+    <timezone id="Asia/Rangoon">Rangoon</timezone>
+    <timezone id="Asia/Krasnoyarsk">Krasnoyarsk</timezone>
+    <timezone id="Asia/Bangkok">Bangkok</timezone>
+    <timezone id="Asia/Hong_Kong">Hong Kong</timezone>
+    <timezone id="Asia/Irkutsk">Irkutsk</timezone>
+    <timezone id="Asia/Kuala_Lumpur">Kuala Lumpur</timezone>
+    <timezone id="Australia/Perth">Perth</timezone>
+    <timezone id="Asia/Taipei">Ora Standard Cina (Taipei)</timezone>
+    <timezone id="Asia/Seoul">Seul</timezone>
+    <timezone id="Asia/Tokyo">Ora Standard Giappone (Tokyo)</timezone>
+    <timezone id="Asia/Yakutsk">Yakutsk</timezone>
+    <timezone id="Australia/Adelaide">Adelaide</timezone>
+    <timezone id="Australia/Darwin">Darwin</timezone>
+    <timezone id="Australia/Brisbane">Brisbane</timezone>
+    <timezone id="Australia/Hobart">Hobart</timezone>
+    <timezone id="Australia/Sydney">Sydney</timezone>
+    <timezone id="Asia/Vladivostok">Vladivostok</timezone>
+    <timezone id="Pacific/Guam">Guam</timezone>
+    <timezone id="Asia/Magadan">Magadan</timezone>
+    <timezone id="Pacific/Auckland">Auckland</timezone>
+    <timezone id="Pacific/Fiji">Figi</timezone>
+    <timezone id="Pacific/Tongatapu">Tongatapu</timezone>
+</timezones>
diff --git a/res/xml-ja/timezones.xml b/res/xml-ja/timezones.xml
new file mode 100644
index 0000000..9a698cf
--- /dev/null
+++ b/res/xml-ja/timezones.xml
@@ -0,0 +1,84 @@
+<timezones>
+    <timezone id="Pacific/Majuro">マジュロ</timezone>
+    <timezone id="Pacific/Midway">ミッドウェー</timezone>
+    <timezone id="Pacific/Honolulu">ホノルル</timezone>
+    <timezone id="America/Anchorage">アンカレッジ</timezone>
+    <timezone id="America/Los_Angeles">アメリカ太平洋時間 (ロサンゼルス)</timezone>
+    <timezone id="America/Tijuana">アメリカ太平洋時間 (ティフアナ)</timezone>
+    <timezone id="America/Phoenix">アメリカ山地時間 (フェニックス)</timezone>
+    <timezone id="America/Chihuahua">チワワ</timezone>
+    <timezone id="America/Denver">アメリカ山地時間 (デンバー)</timezone>
+    <timezone id="America/Costa_Rica">アメリカ中部時間 (コスタリカ共和国)</timezone>
+    <timezone id="America/Chicago">アメリカ中部時間 (シカゴ)</timezone>
+    <timezone id="America/Mexico_City">アメリカ中部時間 (メキシコシティー)</timezone>
+    <timezone id="America/Regina">アメリカ中部時間 (レジャイナ)</timezone>
+    <timezone id="America/Bogota">ボゴタ</timezone>
+    <timezone id="America/New_York">アメリカ東部時間 (ニューヨーク)</timezone>
+    <timezone id="America/Caracas">カラカス</timezone>
+    <timezone id="America/Barbados">大西洋時間 (バルバドス)</timezone>
+    <timezone id="America/Manaus">アマゾン時間 (マナウス)</timezone>
+    <timezone id="America/Santiago">アメリカ/サンチアゴ</timezone>
+    <timezone id="America/St_Johns">ニューファンドランド島標準時 (セントジョンズ)</timezone>
+    <timezone id="America/Araguaina">ブラジリア時間 (アラグァイナ)</timezone>
+    <timezone id="America/Argentina/Buenos_Aires">アルゼンチン時間 (ブエノスアイレス)</timezone>
+    <timezone id="America/Godthab">アメリカ/ゴッドホープ</timezone>
+    <timezone id="America/Montevideo">モンテビデオ</timezone>
+    <timezone id="Atlantic/South_Georgia">南ジョージア島</timezone>
+    <timezone id="Atlantic/Azores">アゾレス諸島</timezone>
+    <timezone id="Atlantic/Cape_Verde">カボベルデ共和国</timezone>
+    <timezone id="Africa/Casablanca">カサブランカ</timezone>
+    <timezone id="Europe/London">グリニッジ標準時 (ヨーロッパ/ロンドン)</timezone>
+    <timezone id="Europe/Amsterdam">中欧標準時 (アムステルダム)</timezone>
+    <timezone id="Europe/Belgrade">中欧標準時 (Belgrade)</timezone>
+    <timezone id="Europe/Brussels">中欧標準時 (ブリュッセル)</timezone>
+    <timezone id="Europe/Sarajevo">中欧標準時 (Sarajevo)</timezone>
+    <timezone id="Africa/Windhoek">ビントフック</timezone>
+    <timezone id="Africa/Brazzaville">西アフリカ時間 (ブラザビル)</timezone>
+    <timezone id="Asia/Amman">東欧標準時 (アンマン)</timezone>
+    <timezone id="Europe/Athens">東欧標準時 (アテネ)</timezone>
+    <timezone id="Asia/Beirut">東欧標準時 (ベイルート)</timezone>
+    <timezone id="Africa/Cairo">東欧標準時 (カイロ)</timezone>
+    <timezone id="Europe/Helsinki">東欧標準時 (ヘルシンキ)</timezone>
+    <timezone id="Asia/Jerusalem">イスラエル標準時 (エルサレム)</timezone>
+    <timezone id="Europe/Minsk">ミンスク</timezone>
+    <timezone id="Africa/Harare">中央アフリカ時間 (ハラーレ)</timezone>
+    <timezone id="Asia/Baghdad">バグダッド</timezone>
+    <timezone id="Europe/Moscow">モスクワ</timezone>
+    <timezone id="Asia/Kuwait">クウェート国</timezone>
+    <timezone id="Africa/Nairobi">東アフリカ時間 (ナイロビ)</timezone>
+    <timezone id="Asia/Tehran">テヘラン</timezone>
+    <timezone id="Asia/Baku">バクー</timezone>
+    <timezone id="Asia/Tbilisi">トビリシ</timezone>
+    <timezone id="Asia/Yerevan">エレバン</timezone>
+    <timezone id="Asia/Dubai">ドバイ</timezone>
+    <timezone id="Asia/Kabul">カブール</timezone>
+    <timezone id="Asia/Karachi">カラチ</timezone>
+    <timezone id="Asia/Oral">オラル</timezone>
+    <timezone id="Asia/Yekaterinburg">エカテリンブルグ</timezone>
+    <timezone id="Asia/Calcutta">Calcutta</timezone>
+    <timezone id="Asia/Colombo">コロンボ</timezone>
+    <timezone id="Asia/Katmandu">カトマンズ</timezone>
+    <timezone id="Asia/Almaty">アルマトイ</timezone>
+    <timezone id="Asia/Rangoon">ラングーン</timezone>
+    <timezone id="Asia/Krasnoyarsk">クラスノヤルスク</timezone>
+    <timezone id="Asia/Bangkok">バンコク</timezone>
+    <timezone id="Asia/Hong_Kong">香港</timezone>
+    <timezone id="Asia/Irkutsk">イルクーツク</timezone>
+    <timezone id="Asia/Kuala_Lumpur">アジア/クアラルンプール</timezone>
+    <timezone id="Australia/Perth">パース</timezone>
+    <timezone id="Asia/Taipei">中国標準時 (台北)</timezone>
+    <timezone id="Asia/Seoul">ソウル</timezone>
+    <timezone id="Asia/Tokyo">日本標準時 (東京)</timezone>
+    <timezone id="Asia/Yakutsk">ヤクーツク</timezone>
+    <timezone id="Australia/Adelaide">アデレード</timezone>
+    <timezone id="Australia/Darwin">ダーウィン</timezone>
+    <timezone id="Australia/Brisbane">ブリスベン</timezone>
+    <timezone id="Australia/Hobart">ホバート</timezone>
+    <timezone id="Australia/Sydney">シドニー</timezone>
+    <timezone id="Asia/Vladivostok">ウラジオストク</timezone>
+    <timezone id="Pacific/Guam">グアム</timezone>
+    <timezone id="Asia/Magadan">マガダン</timezone>
+    <timezone id="Pacific/Auckland">太平洋/オークランド</timezone>
+    <timezone id="Pacific/Fiji">フィジー共和国</timezone>
+    <timezone id="Pacific/Tongatapu">トンガタプ</timezone>
+</timezones>
diff --git a/res/xml-ko/timezones.xml b/res/xml-ko/timezones.xml
new file mode 100644
index 0000000..fcc1519
--- /dev/null
+++ b/res/xml-ko/timezones.xml
@@ -0,0 +1,84 @@
+<timezones>
+    <timezone id="Pacific/Majuro">마주로</timezone>
+    <timezone id="Pacific/Midway">미드웨이</timezone>
+    <timezone id="Pacific/Honolulu">호놀룰루</timezone>
+    <timezone id="America/Anchorage">앵커리지</timezone>
+    <timezone id="America/Los_Angeles">태평양 표준시 (로스앤젤레스)</timezone>
+    <timezone id="America/Tijuana">태평양 표준시 (티후아나)</timezone>
+    <timezone id="America/Phoenix">산지 표준시 (피닉스)</timezone>
+    <timezone id="America/Chihuahua">치와와</timezone>
+    <timezone id="America/Denver">산지 표준시 (덴버)</timezone>
+    <timezone id="America/Costa_Rica">중부 표준시 (코스타리카)</timezone>
+    <timezone id="America/Chicago">중부 표준시 (시카고)</timezone>
+    <timezone id="America/Mexico_City">중부 표준시 (멕시코 시티)</timezone>
+    <timezone id="America/Regina">중부 표준시 (리자이나)</timezone>
+    <timezone id="America/Bogota">보고타</timezone>
+    <timezone id="America/New_York">동부 표준시 (뉴욕)</timezone>
+    <timezone id="America/Caracas">카라카스</timezone>
+    <timezone id="America/Barbados">대서양 표준시 (바베이도스)</timezone>
+    <timezone id="America/Manaus">아마존 표준시 (마나우스)</timezone>
+    <timezone id="America/Santiago">산티아고</timezone>
+    <timezone id="America/St_Johns">뉴펀들랜드 표준시 (세인트존)</timezone>
+    <timezone id="America/Araguaina">브라질리아 표준시 (아라과이나)</timezone>
+    <timezone id="America/Argentina/Buenos_Aires">부에노스 아이레스</timezone>
+    <timezone id="America/Godthab">고드호프</timezone>
+    <timezone id="America/Montevideo">몬테비데오</timezone>
+    <timezone id="Atlantic/South_Georgia">남부 조지아</timezone>
+    <timezone id="Atlantic/Azores">아조레스</timezone>
+    <timezone id="Atlantic/Cape_Verde">카보 베르데</timezone>
+    <timezone id="Africa/Casablanca">카사블랑카</timezone>
+    <timezone id="Europe/London">그리니치 표준시 (런던)</timezone>
+    <timezone id="Europe/Amsterdam">중부유럽 표준시 (암스텔담)</timezone>
+    <timezone id="Europe/Belgrade">중부유럽 표준시 (Belgrade)</timezone>
+    <timezone id="Europe/Brussels">중부유럽 표준시 (브뤼셀)</timezone>
+    <timezone id="Europe/Sarajevo">중부유럽 표준시 (Sarajevo)</timezone>
+    <timezone id="Africa/Windhoek">빈트후크</timezone>
+    <timezone id="Africa/Brazzaville">서아프리카 시간 (브라자빌)</timezone>
+    <timezone id="Asia/Amman">동부유럽 표준시 (암만)</timezone>
+    <timezone id="Europe/Athens">동부유럽 표준시 (아테네)</timezone>
+    <timezone id="Asia/Beirut">동부유럽 표준시 (베이루트)</timezone>
+    <timezone id="Africa/Cairo">동부유럽 표준시 (카이로)</timezone>
+    <timezone id="Europe/Helsinki">동부유럽 표준시 (헬싱키)</timezone>
+    <timezone id="Asia/Jerusalem">이스라엘 표준시 (예루살렘)</timezone>
+    <timezone id="Europe/Minsk">민스크</timezone>
+    <timezone id="Africa/Harare">중앙아프리카 시간 (하라레)</timezone>
+    <timezone id="Asia/Baghdad">바그다드</timezone>
+    <timezone id="Europe/Moscow">모스크바</timezone>
+    <timezone id="Asia/Kuwait">쿠웨이트</timezone>
+    <timezone id="Africa/Nairobi">동아프리카 시간 (나이로비)</timezone>
+    <timezone id="Asia/Tehran">테헤란</timezone>
+    <timezone id="Asia/Baku">바쿠</timezone>
+    <timezone id="Asia/Tbilisi">트빌리시</timezone>
+    <timezone id="Asia/Yerevan">예레반</timezone>
+    <timezone id="Asia/Dubai">두바이</timezone>
+    <timezone id="Asia/Kabul">카불</timezone>
+    <timezone id="Asia/Karachi">카라치</timezone>
+    <timezone id="Asia/Oral">오랄</timezone>
+    <timezone id="Asia/Yekaterinburg">예카테린부르크</timezone>
+    <timezone id="Asia/Calcutta">Calcutta</timezone>
+    <timezone id="Asia/Colombo">콜롬보</timezone>
+    <timezone id="Asia/Katmandu">카트만두</timezone>
+    <timezone id="Asia/Almaty">알마티</timezone>
+    <timezone id="Asia/Rangoon">랑군</timezone>
+    <timezone id="Asia/Krasnoyarsk">크라스노야르스크</timezone>
+    <timezone id="Asia/Bangkok">방콕</timezone>
+    <timezone id="Asia/Hong_Kong">홍콩</timezone>
+    <timezone id="Asia/Irkutsk">이르쿠츠크</timezone>
+    <timezone id="Asia/Kuala_Lumpur">쿠알라룸푸르</timezone>
+    <timezone id="Australia/Perth">서부 오스트레일리아 시간 (퍼스)</timezone>
+    <timezone id="Asia/Taipei">중국 표준시 (타이베이)</timezone>
+    <timezone id="Asia/Seoul">한국 표준시 (서울)</timezone>
+    <timezone id="Asia/Tokyo">일본 표준시 (도쿄)</timezone>
+    <timezone id="Asia/Yakutsk">야쿠츠크</timezone>
+    <timezone id="Australia/Adelaide">중앙 오스트레일리아 시간 (애들레이드)</timezone>
+    <timezone id="Australia/Darwin">중앙 오스트레일리아 시간 (다윈)</timezone>
+    <timezone id="Australia/Brisbane">동부 오스트레일리아 시간 (브리스베인)</timezone>
+    <timezone id="Australia/Hobart">동부 오스트레일리아 시간 (호바트)</timezone>
+    <timezone id="Australia/Sydney">동부 오스트레일리아 시간 (시드니)</timezone>
+    <timezone id="Asia/Vladivostok">블라디보스토크</timezone>
+    <timezone id="Pacific/Guam">괌</timezone>
+    <timezone id="Asia/Magadan">마가단</timezone>
+    <timezone id="Pacific/Auckland">뉴질랜드 시간 (오클랜드)</timezone>
+    <timezone id="Pacific/Fiji">피지</timezone>
+    <timezone id="Pacific/Tongatapu">통가타푸</timezone>
+</timezones>
diff --git a/res/xml-nl/timezones.xml b/res/xml-nl/timezones.xml
new file mode 100644
index 0000000..2b115b3
--- /dev/null
+++ b/res/xml-nl/timezones.xml
@@ -0,0 +1,84 @@
+<timezones>
+    <timezone id="Pacific/Majuro">Majuro</timezone>
+    <timezone id="Pacific/Midway">Midway</timezone>
+    <timezone id="Pacific/Honolulu">Honolulu</timezone>
+    <timezone id="America/Anchorage">Anchorage</timezone>
+    <timezone id="America/Los_Angeles">Pacific-standaardtijd (Los Angeles)</timezone>
+    <timezone id="America/Tijuana">Pacific-standaardtijd (Tijuana)</timezone>
+    <timezone id="America/Phoenix">Mountain-standaardtijd (Phoenix)</timezone>
+    <timezone id="America/Chihuahua">Chihuahua</timezone>
+    <timezone id="America/Denver">Mountain-standaardtijd (Denver)</timezone>
+    <timezone id="America/Costa_Rica">Central-standaardtijd (Costa Rica)</timezone>
+    <timezone id="America/Chicago">Central-standaardtijd (Chicago)</timezone>
+    <timezone id="America/Mexico_City">Central-standaardtijd (Mexico-stad)</timezone>
+    <timezone id="America/Regina">Central-standaardtijd (Regina)</timezone>
+    <timezone id="America/Bogota">Bogotá</timezone>
+    <timezone id="America/New_York">Eastern-standaardtijd (New York)</timezone>
+    <timezone id="America/Caracas">Caracas</timezone>
+    <timezone id="America/Barbados">Atlantic - standaardtijd (Barbados)</timezone>
+    <timezone id="America/Manaus">Manaus</timezone>
+    <timezone id="America/Santiago">Santiago</timezone>
+    <timezone id="America/St_Johns">Newfoundland-standaardtijd (St. Johns)</timezone>
+    <timezone id="America/Araguaina">Araguaina</timezone>
+    <timezone id="America/Argentina/Buenos_Aires">Buenos Aires</timezone>
+    <timezone id="America/Godthab">Godthab</timezone>
+    <timezone id="America/Montevideo">Montevideo</timezone>
+    <timezone id="Atlantic/South_Georgia">Zuid-Georgië</timezone>
+    <timezone id="Atlantic/Azores">Azoren</timezone>
+    <timezone id="Atlantic/Cape_Verde">Kaapverdië</timezone>
+    <timezone id="Africa/Casablanca">Casablanca</timezone>
+    <timezone id="Europe/London">Greenwich Mean Time (Londen)</timezone>
+    <timezone id="Europe/Amsterdam">Midden-Europese standaardtijd (Amsterdam)</timezone>
+    <timezone id="Europe/Belgrade">Midden-Europese standaardtijd (Belgrade)</timezone>
+    <timezone id="Europe/Brussels">Midden-Europese standaardtijd (Brussel)</timezone>
+    <timezone id="Europe/Sarajevo">Midden-Europese standaardtijd (Sarajevo)</timezone>
+    <timezone id="Africa/Windhoek">Windhoek</timezone>
+    <timezone id="Africa/Brazzaville">Brazzaville</timezone>
+    <timezone id="Asia/Amman">Oost-Europese standaardtijd (Amman)</timezone>
+    <timezone id="Europe/Athens">Oost-Europese standaardtijd (Athene)</timezone>
+    <timezone id="Asia/Beirut">Oost-Europese standaardtijd (Beiroet)</timezone>
+    <timezone id="Africa/Cairo">Oost-Europese standaardtijd (Cairo)</timezone>
+    <timezone id="Europe/Helsinki">Oost-Europese standaardtijd (Helsinki)</timezone>
+    <timezone id="Asia/Jerusalem">Israëlische standaardtijd (Jeruzalem)</timezone>
+    <timezone id="Europe/Minsk">Minsk</timezone>
+    <timezone id="Africa/Harare">Harare</timezone>
+    <timezone id="Asia/Baghdad">Baghdad</timezone>
+    <timezone id="Europe/Moscow">Moskou</timezone>
+    <timezone id="Asia/Kuwait">Koeweit</timezone>
+    <timezone id="Africa/Nairobi">Nairobi</timezone>
+    <timezone id="Asia/Tehran">Teheran</timezone>
+    <timezone id="Asia/Baku">Bakoe</timezone>
+    <timezone id="Asia/Tbilisi">Tbilisi</timezone>
+    <timezone id="Asia/Yerevan">Erevan</timezone>
+    <timezone id="Asia/Dubai">Dubai</timezone>
+    <timezone id="Asia/Kabul">Kabul</timezone>
+    <timezone id="Asia/Karachi">Karachi</timezone>
+    <timezone id="Asia/Oral">Oral</timezone>
+    <timezone id="Asia/Yekaterinburg">Jekaterinenburg</timezone>
+    <timezone id="Asia/Calcutta">Calcutta</timezone>
+    <timezone id="Asia/Colombo">Colombo</timezone>
+    <timezone id="Asia/Katmandu">Kathmandu</timezone>
+    <timezone id="Asia/Almaty">Almaty</timezone>
+    <timezone id="Asia/Rangoon">Rangoon</timezone>
+    <timezone id="Asia/Krasnoyarsk">Krasnojarsk</timezone>
+    <timezone id="Asia/Bangkok">Bangkok</timezone>
+    <timezone id="Asia/Hong_Kong">Hongkong</timezone>
+    <timezone id="Asia/Irkutsk">Irkoetsk</timezone>
+    <timezone id="Asia/Kuala_Lumpur">Kuala Lumpur</timezone>
+    <timezone id="Australia/Perth">Perth</timezone>
+    <timezone id="Asia/Taipei">Chinese standaardtijd (Taipei)</timezone>
+    <timezone id="Asia/Seoul">Seoul</timezone>
+    <timezone id="Asia/Tokyo">Japanse standaardtijd (Tokio)</timezone>
+    <timezone id="Asia/Yakutsk">Jakoetsk</timezone>
+    <timezone id="Australia/Adelaide">Adelaide</timezone>
+    <timezone id="Australia/Darwin">Darwin</timezone>
+    <timezone id="Australia/Brisbane">Brisbane</timezone>
+    <timezone id="Australia/Hobart">Hobart</timezone>
+    <timezone id="Australia/Sydney">Sydney</timezone>
+    <timezone id="Asia/Vladivostok">Vladivostok</timezone>
+    <timezone id="Pacific/Guam">Guam</timezone>
+    <timezone id="Asia/Magadan">Magadan</timezone>
+    <timezone id="Pacific/Auckland">Auckland</timezone>
+    <timezone id="Pacific/Fiji">Fiji</timezone>
+    <timezone id="Pacific/Tongatapu">Tongatapu</timezone>
+</timezones>
diff --git a/res/xml-no/timezones.xml b/res/xml-no/timezones.xml
new file mode 100644
index 0000000..d43a17b
--- /dev/null
+++ b/res/xml-no/timezones.xml
@@ -0,0 +1,84 @@
+<timezones>
+    <timezone id="Pacific/Majuro">Majuro</timezone>
+    <timezone id="Pacific/Midway">Midway</timezone>
+    <timezone id="Pacific/Honolulu">Honolulu</timezone>
+    <timezone id="America/Anchorage">Anchorage</timezone>
+    <timezone id="America/Los_Angeles">Los Angeles</timezone>
+    <timezone id="America/Tijuana">Tijuana</timezone>
+    <timezone id="America/Phoenix">Phoenix</timezone>
+    <timezone id="America/Chihuahua">Chihuahua</timezone>
+    <timezone id="America/Denver">Denver</timezone>
+    <timezone id="America/Costa_Rica">Costa Rica</timezone>
+    <timezone id="America/Chicago">Chicago</timezone>
+    <timezone id="America/Mexico_City">Mexico City</timezone>
+    <timezone id="America/Regina">Regina</timezone>
+    <timezone id="America/Bogota">Bogota</timezone>
+    <timezone id="America/New_York">New York</timezone>
+    <timezone id="America/Caracas">Caracas</timezone>
+    <timezone id="America/Barbados">Barbados</timezone>
+    <timezone id="America/Manaus">Manaus</timezone>
+    <timezone id="America/Santiago">Santiago</timezone>
+    <timezone id="America/St_Johns">St. John's</timezone>
+    <timezone id="America/Araguaina">Araguaina</timezone>
+    <timezone id="America/Argentina/Buenos_Aires">Buenos Aires</timezone>
+    <timezone id="America/Godthab">Godthab</timezone>
+    <timezone id="America/Montevideo">Montevideo</timezone>
+    <timezone id="Atlantic/South_Georgia">South Georgia</timezone>
+    <timezone id="Atlantic/Azores">Azores</timezone>
+    <timezone id="Atlantic/Cape_Verde">Cape Verde</timezone>
+    <timezone id="Africa/Casablanca">Casablanca</timezone>
+    <timezone id="Europe/London">London</timezone>
+    <timezone id="Europe/Amsterdam">Amsterdam</timezone>
+    <timezone id="Europe/Belgrade">Belgrade</timezone>
+    <timezone id="Europe/Brussels">Brussels</timezone>
+    <timezone id="Europe/Sarajevo">Sarajevo</timezone>
+    <timezone id="Africa/Windhoek">Windhoek</timezone>
+    <timezone id="Africa/Brazzaville">Brazzaville</timezone>
+    <timezone id="Asia/Amman">Amman</timezone>
+    <timezone id="Europe/Athens">Athens</timezone>
+    <timezone id="Asia/Beirut">Beirut</timezone>
+    <timezone id="Africa/Cairo">Cairo</timezone>
+    <timezone id="Europe/Helsinki">Helsinki</timezone>
+    <timezone id="Asia/Jerusalem">Jerusalem</timezone>
+    <timezone id="Europe/Minsk">Minsk</timezone>
+    <timezone id="Africa/Harare">Harare</timezone>
+    <timezone id="Asia/Baghdad">Baghdad</timezone>
+    <timezone id="Europe/Moscow">Moscow</timezone>
+    <timezone id="Asia/Kuwait">Kuwait</timezone>
+    <timezone id="Africa/Nairobi">Nairobi</timezone>
+    <timezone id="Asia/Tehran">Tehran</timezone>
+    <timezone id="Asia/Baku">Baku</timezone>
+    <timezone id="Asia/Tbilisi">Tbilisi</timezone>
+    <timezone id="Asia/Yerevan">Yerevan</timezone>
+    <timezone id="Asia/Dubai">Dubai</timezone>
+    <timezone id="Asia/Kabul">Kabul</timezone>
+    <timezone id="Asia/Karachi">Karachi</timezone>
+    <timezone id="Asia/Oral">Oral</timezone>
+    <timezone id="Asia/Yekaterinburg">Yekaterinburg</timezone>
+    <timezone id="Asia/Calcutta">Calcutta</timezone>
+    <timezone id="Asia/Colombo">Colombo</timezone>
+    <timezone id="Asia/Katmandu">Katmandu</timezone>
+    <timezone id="Asia/Almaty">Almaty</timezone>
+    <timezone id="Asia/Rangoon">Rangoon</timezone>
+    <timezone id="Asia/Krasnoyarsk">Krasnoyarsk</timezone>
+    <timezone id="Asia/Bangkok">Bangkok</timezone>
+    <timezone id="Asia/Hong_Kong">Hong Kong</timezone>
+    <timezone id="Asia/Irkutsk">Irkutsk</timezone>
+    <timezone id="Asia/Kuala_Lumpur">Kuala Lumpur</timezone>
+    <timezone id="Australia/Perth">Perth</timezone>
+    <timezone id="Asia/Taipei">Taipei</timezone>
+    <timezone id="Asia/Seoul">Seoul</timezone>
+    <timezone id="Asia/Tokyo">Tokyo</timezone>
+    <timezone id="Asia/Yakutsk">Yakutsk</timezone>
+    <timezone id="Australia/Adelaide">Adelaide</timezone>
+    <timezone id="Australia/Darwin">Darwin</timezone>
+    <timezone id="Australia/Brisbane">Brisbane</timezone>
+    <timezone id="Australia/Hobart">Hobart</timezone>
+    <timezone id="Australia/Sydney">Sydney</timezone>
+    <timezone id="Asia/Vladivostok">Vladivostok</timezone>
+    <timezone id="Pacific/Guam">Guam</timezone>
+    <timezone id="Asia/Magadan">Magadan</timezone>
+    <timezone id="Pacific/Auckland">Auckland</timezone>
+    <timezone id="Pacific/Fiji">Fiji</timezone>
+    <timezone id="Pacific/Tongatapu">Tongatapu</timezone>
+</timezones>
diff --git a/res/xml-pl/timezones.xml b/res/xml-pl/timezones.xml
new file mode 100644
index 0000000..8693f21
--- /dev/null
+++ b/res/xml-pl/timezones.xml
@@ -0,0 +1,84 @@
+<timezones>
+    <timezone id="Pacific/Majuro">Majuro</timezone>
+    <timezone id="Pacific/Midway">Midway</timezone>
+    <timezone id="Pacific/Honolulu">Honolulu</timezone>
+    <timezone id="America/Anchorage">Anchorage</timezone>
+    <timezone id="America/Los_Angeles">Los Angeles</timezone>
+    <timezone id="America/Tijuana">Tijuana</timezone>
+    <timezone id="America/Phoenix">Phoenix</timezone>
+    <timezone id="America/Chihuahua">Chihuahua</timezone>
+    <timezone id="America/Denver">Denver</timezone>
+    <timezone id="America/Costa_Rica">Kostaryka</timezone>
+    <timezone id="America/Chicago">Chicago</timezone>
+    <timezone id="America/Mexico_City">Meksyk</timezone>
+    <timezone id="America/Regina">Regina</timezone>
+    <timezone id="America/Bogota">Kolumbia</timezone>
+    <timezone id="America/New_York">Nowy Jork</timezone>
+    <timezone id="America/Caracas">Wenezuela</timezone>
+    <timezone id="America/Barbados">Barbados</timezone>
+    <timezone id="America/Manaus">Manaus</timezone>
+    <timezone id="America/Santiago">Santiago</timezone>
+    <timezone id="America/St_Johns">St. John's</timezone>
+    <timezone id="America/Araguaina">Araguaina</timezone>
+    <timezone id="America/Argentina/Buenos_Aires">Buenos Aires</timezone>
+    <timezone id="America/Godthab">Grenlandia</timezone>
+    <timezone id="America/Montevideo">Urugwaj</timezone>
+    <timezone id="Atlantic/South_Georgia">Georgia Południowa</timezone>
+    <timezone id="Atlantic/Azores">Azory</timezone>
+    <timezone id="Atlantic/Cape_Verde">Zielony Przylądek</timezone>
+    <timezone id="Africa/Casablanca">Casablanca</timezone>
+    <timezone id="Europe/London">Londyn</timezone>
+    <timezone id="Europe/Amsterdam">Holandia</timezone>
+    <timezone id="Europe/Belgrade">Belgrad</timezone>
+    <timezone id="Europe/Brussels">Bruksela</timezone>
+    <timezone id="Europe/Sarajevo">Sarajewo</timezone>
+    <timezone id="Africa/Windhoek">Windhuk</timezone>
+    <timezone id="Africa/Brazzaville">Kongo Brazzaville</timezone>
+    <timezone id="Asia/Amman">Jordania</timezone>
+    <timezone id="Europe/Athens">Ateny</timezone>
+    <timezone id="Asia/Beirut">Bejrut</timezone>
+    <timezone id="Africa/Cairo">Kair</timezone>
+    <timezone id="Europe/Helsinki">Finlandia</timezone>
+    <timezone id="Asia/Jerusalem">Jerozolima</timezone>
+    <timezone id="Europe/Minsk">Mińsk</timezone>
+    <timezone id="Africa/Harare">Harare</timezone>
+    <timezone id="Asia/Baghdad">Bagdad</timezone>
+    <timezone id="Europe/Moscow">Moskwa</timezone>
+    <timezone id="Asia/Kuwait">Kuwejt</timezone>
+    <timezone id="Africa/Nairobi">Nairobi</timezone>
+    <timezone id="Asia/Tehran">Teheran</timezone>
+    <timezone id="Asia/Baku">Azerbejdżan</timezone>
+    <timezone id="Asia/Tbilisi">Gruzja</timezone>
+    <timezone id="Asia/Yerevan">Erewan</timezone>
+    <timezone id="Asia/Dubai">Dubaj</timezone>
+    <timezone id="Asia/Kabul">Afganistan</timezone>
+    <timezone id="Asia/Karachi">Karaczi</timezone>
+    <timezone id="Asia/Oral">Uralsk</timezone>
+    <timezone id="Asia/Yekaterinburg">Jekaterynburg</timezone>
+    <timezone id="Asia/Calcutta">Kalkuta</timezone>
+    <timezone id="Asia/Colombo">Kolombo</timezone>
+    <timezone id="Asia/Katmandu">Nepal</timezone>
+    <timezone id="Asia/Almaty">Ałma Ata</timezone>
+    <timezone id="Asia/Rangoon">Rangun</timezone>
+    <timezone id="Asia/Krasnoyarsk">Krasnojarsk</timezone>
+    <timezone id="Asia/Bangkok">Tajlandia</timezone>
+    <timezone id="Asia/Hong_Kong">Hongkong</timezone>
+    <timezone id="Asia/Irkutsk">Irkuck</timezone>
+    <timezone id="Asia/Kuala_Lumpur">Kuala Lumpur</timezone>
+    <timezone id="Australia/Perth">Perth</timezone>
+    <timezone id="Asia/Taipei">Tajpej</timezone>
+    <timezone id="Asia/Seoul">Seul</timezone>
+    <timezone id="Asia/Tokyo">Tokio</timezone>
+    <timezone id="Asia/Yakutsk">Jakuck</timezone>
+    <timezone id="Australia/Adelaide">Adelajda</timezone>
+    <timezone id="Australia/Darwin">Darwin</timezone>
+    <timezone id="Australia/Brisbane">Brisbane</timezone>
+    <timezone id="Australia/Hobart">Hobart</timezone>
+    <timezone id="Australia/Sydney">Sydney</timezone>
+    <timezone id="Asia/Vladivostok">Władywostok</timezone>
+    <timezone id="Pacific/Guam">Guam</timezone>
+    <timezone id="Asia/Magadan">Magadan</timezone>
+    <timezone id="Pacific/Auckland">Auckland</timezone>
+    <timezone id="Pacific/Fiji">Fidżi</timezone>
+    <timezone id="Pacific/Tongatapu">Tonga</timezone>
+</timezones>
diff --git a/res/xml-ru/timezones.xml b/res/xml-ru/timezones.xml
new file mode 100644
index 0000000..2a60f8f
--- /dev/null
+++ b/res/xml-ru/timezones.xml
@@ -0,0 +1,84 @@
+<timezones>
+    <timezone id="Pacific/Majuro">Маджуро</timezone>
+    <timezone id="Pacific/Midway">Мидуэй, о-ва</timezone>
+    <timezone id="Pacific/Honolulu">Гонолулу</timezone>
+    <timezone id="America/Anchorage">Анкоридж</timezone>
+    <timezone id="America/Los_Angeles">Лос-Анджелес</timezone>
+    <timezone id="America/Tijuana">Тихуана</timezone>
+    <timezone id="America/Phoenix">Финикс</timezone>
+    <timezone id="America/Chihuahua">Чиуауа</timezone>
+    <timezone id="America/Denver">Денвер</timezone>
+    <timezone id="America/Costa_Rica">Коста-Рика</timezone>
+    <timezone id="America/Chicago">Чикаго</timezone>
+    <timezone id="America/Mexico_City">Мехико</timezone>
+    <timezone id="America/Regina">Реджайна</timezone>
+    <timezone id="America/Bogota">Богота</timezone>
+    <timezone id="America/New_York">Нью-Йорк</timezone>
+    <timezone id="America/Caracas">Каракас</timezone>
+    <timezone id="America/Barbados">Барбадос</timezone>
+    <timezone id="America/Manaus">Манаус</timezone>
+    <timezone id="America/Santiago">Сантьяго</timezone>
+    <timezone id="America/St_Johns">Сент-Джонс</timezone>
+    <timezone id="America/Araguaina">Арагуаина</timezone>
+    <timezone id="America/Argentina/Buenos_Aires">Буэнос-Айрес</timezone>
+    <timezone id="America/Godthab">Готхоб</timezone>
+    <timezone id="America/Montevideo">Монтевидео</timezone>
+    <timezone id="Atlantic/South_Georgia">Ю.Джорджия и Ю.Сэндвинчевы о-ва</timezone>
+    <timezone id="Atlantic/Azores">Азорские о-ва</timezone>
+    <timezone id="Atlantic/Cape_Verde">Острова Зеленого Мыса</timezone>
+    <timezone id="Africa/Casablanca">Касабланка</timezone>
+    <timezone id="Europe/London">Лондон</timezone>
+    <timezone id="Europe/Amsterdam">Амстердам</timezone>
+    <timezone id="Europe/Belgrade">Белград</timezone>
+    <timezone id="Europe/Brussels">Брюссель</timezone>
+    <timezone id="Europe/Sarajevo">Сараево</timezone>
+    <timezone id="Africa/Windhoek">Виндхук</timezone>
+    <timezone id="Africa/Brazzaville">Браззавиль</timezone>
+    <timezone id="Asia/Amman">Амман</timezone>
+    <timezone id="Europe/Athens">Афины</timezone>
+    <timezone id="Asia/Beirut">Бейрут</timezone>
+    <timezone id="Africa/Cairo">Каир</timezone>
+    <timezone id="Europe/Helsinki">Хельсинки</timezone>
+    <timezone id="Asia/Jerusalem">Иерусалим</timezone>
+    <timezone id="Europe/Minsk">Минск</timezone>
+    <timezone id="Africa/Harare">Хараре</timezone>
+    <timezone id="Asia/Baghdad">Багдад</timezone>
+    <timezone id="Europe/Moscow">Москва</timezone>
+    <timezone id="Asia/Kuwait">Кувейт</timezone>
+    <timezone id="Africa/Nairobi">Найроби</timezone>
+    <timezone id="Asia/Tehran">Тегеран</timezone>
+    <timezone id="Asia/Baku">Баку</timezone>
+    <timezone id="Asia/Tbilisi">Тбилиси</timezone>
+    <timezone id="Asia/Yerevan">Ереван</timezone>
+    <timezone id="Asia/Dubai">Дубай</timezone>
+    <timezone id="Asia/Kabul">Кабул</timezone>
+    <timezone id="Asia/Karachi">Карачи</timezone>
+    <timezone id="Asia/Oral">Орал (Уральск)</timezone>
+    <timezone id="Asia/Yekaterinburg">Екатеринбург</timezone>
+    <timezone id="Asia/Calcutta">Калькутта</timezone>
+    <timezone id="Asia/Colombo">Коломбо</timezone>
+    <timezone id="Asia/Katmandu">Катманду</timezone>
+    <timezone id="Asia/Almaty">Алматы</timezone>
+    <timezone id="Asia/Rangoon">Рангун</timezone>
+    <timezone id="Asia/Krasnoyarsk">Красноярск</timezone>
+    <timezone id="Asia/Bangkok">Бангкок</timezone>
+    <timezone id="Asia/Hong_Kong">Гонконг</timezone>
+    <timezone id="Asia/Irkutsk">Иркутск</timezone>
+    <timezone id="Asia/Kuala_Lumpur">Куала-Лумпур</timezone>
+    <timezone id="Australia/Perth">Перт</timezone>
+    <timezone id="Asia/Taipei">Тайбэй</timezone>
+    <timezone id="Asia/Seoul">Сеул</timezone>
+    <timezone id="Asia/Tokyo">Токио</timezone>
+    <timezone id="Asia/Yakutsk">Якутск</timezone>
+    <timezone id="Australia/Adelaide">Аделаида</timezone>
+    <timezone id="Australia/Darwin">Дарвин</timezone>
+    <timezone id="Australia/Brisbane">Брисбен</timezone>
+    <timezone id="Australia/Hobart">Хобарт</timezone>
+    <timezone id="Australia/Sydney">Сидней</timezone>
+    <timezone id="Asia/Vladivostok">Владивосток</timezone>
+    <timezone id="Pacific/Guam">Гуам</timezone>
+    <timezone id="Asia/Magadan">Магадан</timezone>
+    <timezone id="Pacific/Auckland">Окленд</timezone>
+    <timezone id="Pacific/Fiji">Фиджи</timezone>
+    <timezone id="Pacific/Tongatapu">Тонгатапу</timezone>
+</timezones>
diff --git a/res/xml-zh/timezones.xml b/res/xml-zh/timezones.xml
new file mode 100644
index 0000000..0d61deb
--- /dev/null
+++ b/res/xml-zh/timezones.xml
@@ -0,0 +1,84 @@
+<timezones>
+    <timezone id="Pacific/Majuro">马朱罗</timezone>
+    <timezone id="Pacific/Midway">中途岛</timezone>
+    <timezone id="Pacific/Honolulu">檀香山</timezone>
+    <timezone id="America/Anchorage">安克雷奇</timezone>
+    <timezone id="America/Los_Angeles">太平洋标准时间 (洛杉矶)</timezone>
+    <timezone id="America/Tijuana">太平洋标准时间 (提华纳)</timezone>
+    <timezone id="America/Phoenix">山区标准时间 (凤凰城)</timezone>
+    <timezone id="America/Chihuahua">奇瓦瓦</timezone>
+    <timezone id="America/Denver">山区标准时间 (丹佛)</timezone>
+    <timezone id="America/Costa_Rica">中部标准时间 (哥斯达黎加)</timezone>
+    <timezone id="America/Chicago">中部标准时间 (芝加哥)</timezone>
+    <timezone id="America/Mexico_City">中部标准时间 (墨西哥城)</timezone>
+    <timezone id="America/Regina">中部标准时间 (里贾纳)</timezone>
+    <timezone id="America/Bogota">波哥大</timezone>
+    <timezone id="America/New_York">东部标准时间 (纽约)</timezone>
+    <timezone id="America/Caracas">加拉加斯</timezone>
+    <timezone id="America/Barbados">大西洋标准时间 (巴巴多斯)</timezone>
+    <timezone id="America/Manaus">亚马逊时间 (马瑙斯)</timezone>
+    <timezone id="America/Santiago">圣地亚哥</timezone>
+    <timezone id="America/St_Johns">纽芬兰标准时间 (圣约翰)</timezone>
+    <timezone id="America/Araguaina">阿拉瓜伊纳</timezone>
+    <timezone id="America/Argentina/Buenos_Aires">布宜诺斯艾利斯</timezone>
+    <timezone id="America/Godthab">戈特霍布</timezone>
+    <timezone id="America/Montevideo">蒙得维的亚</timezone>
+    <timezone id="Atlantic/South_Georgia">南乔治亚</timezone>
+    <timezone id="Atlantic/Azores">亚述尔群岛</timezone>
+    <timezone id="Atlantic/Cape_Verde">佛得角</timezone>
+    <timezone id="Africa/Casablanca">卡萨布兰卡</timezone>
+    <timezone id="Europe/London">格林尼治标准时间 (伦敦)</timezone>
+    <timezone id="Europe/Amsterdam">中欧标准时间 (阿姆斯特丹)</timezone>
+    <timezone id="Europe/Belgrade">中欧标准时间 (贝尔格莱德)</timezone>
+    <timezone id="Europe/Brussels">中欧标准时间 (布鲁塞尔)</timezone>
+    <timezone id="Europe/Sarajevo">中欧标准时间 (萨拉热窝)</timezone>
+    <timezone id="Africa/Windhoek">温得和克</timezone>
+    <timezone id="Africa/Brazzaville">西部非洲时间 (布拉扎维)</timezone>
+    <timezone id="Asia/Amman">东欧标准时间 (安曼)</timezone>
+    <timezone id="Europe/Athens">东欧标准时间 (雅典)</timezone>
+    <timezone id="Asia/Beirut">东欧标准时间 (贝鲁特)</timezone>
+    <timezone id="Africa/Cairo">东欧标准时间 (开罗)</timezone>
+    <timezone id="Europe/Helsinki">东欧标准时间 (赫尔辛基)</timezone>
+    <timezone id="Asia/Jerusalem">以色列标准时间 (耶路撒冷)</timezone>
+    <timezone id="Europe/Minsk">明斯克</timezone>
+    <timezone id="Africa/Harare">非洲中部时间 (哈拉雷)</timezone>
+    <timezone id="Asia/Baghdad">巴格达</timezone>
+    <timezone id="Europe/Moscow">莫斯科</timezone>
+    <timezone id="Asia/Kuwait">科威特</timezone>
+    <timezone id="Africa/Nairobi">非洲东部时间 (内罗毕)</timezone>
+    <timezone id="Asia/Tehran">德黑兰</timezone>
+    <timezone id="Asia/Baku">巴库</timezone>
+    <timezone id="Asia/Tbilisi">第比利斯</timezone>
+    <timezone id="Asia/Yerevan">埃里温</timezone>
+    <timezone id="Asia/Dubai">迪拜</timezone>
+    <timezone id="Asia/Kabul">喀布尔</timezone>
+    <timezone id="Asia/Karachi">卡拉奇</timezone>
+    <timezone id="Asia/Oral">乌拉尔</timezone>
+    <timezone id="Asia/Yekaterinburg">叶卡捷林堡</timezone>
+    <timezone id="Asia/Calcutta">加尔各答</timezone>
+    <timezone id="Asia/Colombo">科伦坡</timezone>
+    <timezone id="Asia/Katmandu">加德满都</timezone>
+    <timezone id="Asia/Almaty">阿拉木图</timezone>
+    <timezone id="Asia/Rangoon">仰光</timezone>
+    <timezone id="Asia/Krasnoyarsk">克拉斯诺亚尔斯克</timezone>
+    <timezone id="Asia/Bangkok">曼谷</timezone>
+    <timezone id="Asia/Hong_Kong">香港</timezone>
+    <timezone id="Asia/Irkutsk">伊尔库茨克</timezone>
+    <timezone id="Asia/Kuala_Lumpur">吉隆坡</timezone>
+    <timezone id="Australia/Perth">佩思</timezone>
+    <timezone id="Asia/Taipei">中国标准时间 (台北)</timezone>
+    <timezone id="Asia/Seoul">首尔</timezone>
+    <timezone id="Asia/Tokyo">日本标准时间 (东京)</timezone>
+    <timezone id="Asia/Yakutsk">雅库茨克</timezone>
+    <timezone id="Australia/Adelaide">阿德莱德</timezone>
+    <timezone id="Australia/Darwin">达尔文</timezone>
+    <timezone id="Australia/Brisbane">布里斯班</timezone>
+    <timezone id="Australia/Hobart">霍巴特</timezone>
+    <timezone id="Australia/Sydney">悉尼</timezone>
+    <timezone id="Asia/Vladivostok">符拉迪沃斯托克</timezone>
+    <timezone id="Pacific/Guam">关岛</timezone>
+    <timezone id="Asia/Magadan">马加丹</timezone>
+    <timezone id="Pacific/Auckland">奥克兰</timezone>
+    <timezone id="Pacific/Fiji">斐济</timezone>
+    <timezone id="Pacific/Tongatapu">东加塔布</timezone>
+</timezones>
