diff --git a/res/values-af/strings.xml b/res/values-af/strings.xml
index 867ef25..590a988 100644
--- a/res/values-af/strings.xml
+++ b/res/values-af/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Foon-luitoon"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibreer ook vir oproepe"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Belbladklanke"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Toonlengte vir belblad"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normaal"</item>
+    <item msgid="6177579030803486015">"Lank"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Vinnige antwoorde"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Oproepe"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Oproeprekeninge"</string>
diff --git a/res/values-am/strings.xml b/res/values-am/strings.xml
index e5fc1a2..cd99a30 100644
--- a/res/values-am/strings.xml
+++ b/res/values-am/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"የስልክ ጥሪ ቅላጼ"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"እንዲሁም ለጥሪዎችም ንዘር"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"የመደወያ ሰሌዳ ቅላጼዎች"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"የስልክ ሰሌዳ ድምጽ ርዝመት"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"መደበኛ"</item>
+    <item msgid="6177579030803486015">"ረጅም"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"ፈጣን ምላሾች"</string>
     <string name="call_settings_label" msgid="313434211353070209">"ጥሪዎች"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"የመደወያ መለያዎች"</string>
diff --git a/res/values-ar/strings.xml b/res/values-ar/strings.xml
index f081c1b..a450bfb 100644
--- a/res/values-ar/strings.xml
+++ b/res/values-ar/strings.xml
@@ -188,10 +188,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"نغمة رنين الهاتف"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"الاهتزاز أيضًا مع المكالمات"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"نغمات لوحة الاتصال"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"طول نغمة لوحة الاتصال"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"عادية"</item>
+    <item msgid="6177579030803486015">"طويلة"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"الردود السريعة"</string>
     <string name="call_settings_label" msgid="313434211353070209">"المكالمات"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"حسابات الاتصال"</string>
diff --git a/res/values-bg/strings.xml b/res/values-bg/strings.xml
index e26a90e..5c3cf83 100644
--- a/res/values-bg/strings.xml
+++ b/res/values-bg/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Опции за показване"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Звуци и вибриране"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Достъпност"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Мелодия на телефона"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Вибриране и при обаждания"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Клавиат. за набиране: Мелодии"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Продължителност на звука при набиране"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Нормално"</item>
+    <item msgid="6177579030803486015">"Продължително"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Бързи отговори"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Обаждания"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Профили за обаждане"</string>
diff --git a/res/values-bn-rBD/strings.xml b/res/values-bn-rBD/strings.xml
index 53a6b20..5b6ea15 100644
--- a/res/values-bn-rBD/strings.xml
+++ b/res/values-bn-rBD/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"প্রদর্শনের বিকল্পগুলি"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"শব্দ এবং কম্পন"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"অ্যাক্সেসযোগ্যতা"</string>
     <string name="ringtone_title" msgid="760362035635084653">"ফোন রিংটোন"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"এছাড়াও কল এলে কম্পিত করুন"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ডায়ালপ্যাড টোনগুলি"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ডায়ালপ্যাড স্বরের দৈর্ঘ্য"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"স্বাভাবিক"</item>
+    <item msgid="6177579030803486015">"দীর্ঘ"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"দ্রুত প্রতিক্রিয়াগুলি"</string>
     <string name="call_settings_label" msgid="313434211353070209">"কল"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"কলিং অ্যাকাউন্টগুলি"</string>
diff --git a/res/values-ca/strings.xml b/res/values-ca/strings.xml
index 5ecab8d..cd9368b 100644
--- a/res/values-ca/strings.xml
+++ b/res/values-ca/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"So de trucada"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibra també per a les trucades"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tons del teclat"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Durada del to del teclat"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Llarg"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respostes ràpides"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Trucades"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Comptes per a trucades"</string>
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index 51a6268..3d6bfe2 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -182,15 +182,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Možnosti zobrazení"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Zvuky a vibrace"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Usnadnění"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Vyzváněcí tón telefonu"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrovat také u volání"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tóny číselníku"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Délka tónu číselníku"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normální"</item>
+    <item msgid="6177579030803486015">"Dlouhé"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Rychlé odpovědi"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Volání"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Účty pro volání"</string>
diff --git a/res/values-da/strings.xml b/res/values-da/strings.xml
index bdd66db..19ca89a 100644
--- a/res/values-da/strings.xml
+++ b/res/values-da/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Ringetone for opkald"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrer også ved opkald"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Toner for numerisk tastatur"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Tonelængde for numerisk tastatur"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Lang"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Hurtigt svar"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Opkald"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Opkaldskonti"</string>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index d223de2..9883057 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Anzeigeoptionen"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Töne und Vibration"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Bedienungshilfen"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Klingelton"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Bei Anrufen auch vibrieren"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Wähltastentöne"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Länge der Wähltastentöne"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Lang"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Kurzantworten"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Anrufe"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Anrufkonten"</string>
diff --git a/res/values-el/strings.xml b/res/values-el/strings.xml
index 9574924..c553c14 100644
--- a/res/values-el/strings.xml
+++ b/res/values-el/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Ήχος κλήσης τηλεφώνου"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Επίσης δόνηση για κλήσεις"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Τόνοι πληκτρολογίου κλήσης"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Διάρκεια ήχου πληκτρολογίου κλήσης"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Κανονική"</item>
+    <item msgid="6177579030803486015">"Παρατεταμένη"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Γρήγορες απαντήσεις"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Κλήσεις"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Λογαριασμοί κλήσης"</string>
diff --git a/res/values-en-rGB/strings.xml b/res/values-en-rGB/strings.xml
index 91e7ffd..5a8e7a6 100644
--- a/res/values-en-rGB/strings.xml
+++ b/res/values-en-rGB/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Phone ringtone"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Also vibrate for calls"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Dialpad tones"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Dialpad tone length"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Long"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Quick responses"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Calls"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Calling accounts"</string>
diff --git a/res/values-en-rIN/strings.xml b/res/values-en-rIN/strings.xml
index 91e7ffd..5a8e7a6 100644
--- a/res/values-en-rIN/strings.xml
+++ b/res/values-en-rIN/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Phone ringtone"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Also vibrate for calls"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Dialpad tones"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Dialpad tone length"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Long"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Quick responses"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Calls"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Calling accounts"</string>
diff --git a/res/values-es-rUS/strings.xml b/res/values-es-rUS/strings.xml
index f53fd8a..c461035 100644
--- a/res/values-es-rUS/strings.xml
+++ b/res/values-es-rUS/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Tono del teléfono"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrar también en llamadas"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tonos del teclado"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Longitud del tono del teclado"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Largo"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respuestas rápidas"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Llamadas"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Cuentas telefónicas"</string>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index 83f1b0d..c6e029a 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Tono del teléfono"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrar también en llamadas"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tonos del teclado"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Duración del tono del teclado"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Tono normal"</item>
+    <item msgid="6177579030803486015">"Tono largo"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respuestas rápidas"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Llamadas"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Cuentas de llamadas"</string>
diff --git a/res/values-et-rEE/strings.xml b/res/values-et-rEE/strings.xml
index 8611cc6..83b3743 100644
--- a/res/values-et-rEE/strings.xml
+++ b/res/values-et-rEE/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Kuvamisvalikud"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Helid ja vibratsioon"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Juurdepääsetavus"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Telefoni helin"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibreeri ka kõnede puhul"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Valimisklahvistiku toonid"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Valimisklahvistiku tooni pikkus"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Tavaline"</item>
+    <item msgid="6177579030803486015">"Pikk"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Kiirvastused"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Kõned"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Helistamiskontod"</string>
diff --git a/res/values-eu-rES/strings.xml b/res/values-eu-rES/strings.xml
index 470e9c9..2f7bc1b 100644
--- a/res/values-eu-rES/strings.xml
+++ b/res/values-eu-rES/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Telefonoaren tonua"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Dardara deiak jasotzean ere"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Markagailuaren tonuak"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Markagailuaren tonuaren iraupena"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normala"</item>
+    <item msgid="6177579030803486015">"Luzea"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Erantzun bizkorrak"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Deiak"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Deiak egiteko kontuak"</string>
diff --git a/res/values-fa/strings.xml b/res/values-fa/strings.xml
index 6ff2a64..3845cc0 100644
--- a/res/values-fa/strings.xml
+++ b/res/values-fa/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"، "</string>
     <string name="display_options_title" msgid="7812852361055667468">"گزینه‌های نمایش"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"صدا و لرزش"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"دسترس‌پذیری"</string>
     <string name="ringtone_title" msgid="760362035635084653">"آهنگ زنگ تلفن"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"تماس‌‌ها لرزش هم داشته باشند"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"صداهای صفحه شماره‌گیری"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"طول آهنگ صفحه شماره‌گیری"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"عادی"</item>
+    <item msgid="6177579030803486015">"طولانی"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"پاسخ‌های سریع"</string>
     <string name="call_settings_label" msgid="313434211353070209">"تماس‌ها"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"حساب‌های تماس اینترنتی"</string>
diff --git a/res/values-fi/strings.xml b/res/values-fi/strings.xml
index 8360c33..a0693f8 100644
--- a/res/values-fi/strings.xml
+++ b/res/values-fi/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Puhelimen soittoääni"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Värinä myös puheluille"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Näppäimistön äänet"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Näppäimistön äänen pituus"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normaali"</item>
+    <item msgid="6177579030803486015">"Pitkä"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Pikavastaukset"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Puhelut"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Puhelutilit"</string>
diff --git a/res/values-fr-rCA/strings.xml b/res/values-fr-rCA/strings.xml
index cb44a42..917cdfb 100644
--- a/res/values-fr-rCA/strings.xml
+++ b/res/values-fr-rCA/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Sonnerie du téléphone"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrer aussi pour les appels"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tonalités du clavier"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Durée des tonalités du pavé numérique"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normale"</item>
+    <item msgid="6177579030803486015">"Longue"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Réponses rapides"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Appels"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Comptes d\'appel"</string>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index faff324..a75074e 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Options d\'affichage"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Sons et vibreur"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Accessibilité"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Sonnerie du téléphone"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibreur aussi pour les appels"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Son du clavier"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Durée de la tonalité du clavier"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normale"</item>
+    <item msgid="6177579030803486015">"Longue"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Réponses rapides"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Appels"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Comptes téléphoniques"</string>
diff --git a/res/values-gl-rES/strings.xml b/res/values-gl-rES/strings.xml
index f175700..f1389bd 100644
--- a/res/values-gl-rES/strings.xml
+++ b/res/values-gl-rES/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Ton de chamada do teléfono"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrar tamén nas chamadas"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tons do teclado de marcación"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Duración do ton do teclado de marcación"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Longa"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respostas rápidas"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Chamadas"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Contas de chamadas"</string>
diff --git a/res/values-hi/strings.xml b/res/values-hi/strings.xml
index 0055aa1..37334a0 100644
--- a/res/values-hi/strings.xml
+++ b/res/values-hi/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"प्रदर्शन विकल्प"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ध्‍वनि और कंपन"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"सरल उपयोग"</string>
     <string name="ringtone_title" msgid="760362035635084653">"फ़ोन रिंगटोन"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"कॉल के लिए भी कंपन"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"डायलपैड टोन"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"डायलपैड टोन की अवधि"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"सामान्य"</item>
+    <item msgid="6177579030803486015">"लंबी"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"झटपट उत्तर"</string>
     <string name="call_settings_label" msgid="313434211353070209">"कॉल"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"कॉलिंग खाते"</string>
diff --git a/res/values-hr/strings.xml b/res/values-hr/strings.xml
index 8ca362d..001ebfe 100644
--- a/res/values-hr/strings.xml
+++ b/res/values-hr/strings.xml
@@ -185,10 +185,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Melodija zvona telefona"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibracija i za pozive"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tonovi biranja brojeva"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Duljina zvuka tipkovnice"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Uobičajena"</item>
+    <item msgid="6177579030803486015">"Duga"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Brzi odgovori"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Pozivi"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Pozivanje računa"</string>
diff --git a/res/values-hu/strings.xml b/res/values-hu/strings.xml
index a5de42c..7162624 100644
--- a/res/values-hu/strings.xml
+++ b/res/values-hu/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Telefon csengőhangja"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Rezgés a hívásoknál is"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tárcsázó hangjai"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Tárcsázási hang hossza"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normál"</item>
+    <item msgid="6177579030803486015">"Hosszú"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Gyors válaszok"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Hívások"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Telefonos fiókok"</string>
diff --git a/res/values-hy-rAM/strings.xml b/res/values-hy-rAM/strings.xml
index afaf1e3..140225f 100644
--- a/res/values-hy-rAM/strings.xml
+++ b/res/values-hy-rAM/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Ցուցադրման ընտրանքներ"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Ձայներ և թրթռում"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Մատչելիություն"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Հեռախոսի զանգերանգ"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Նաև թրթռալ զանգերի ժամանակ"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Թվաշարի ձայներանգներ"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Թվաշարի ձայնային ազդանշանի երկարություն"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Սովորական"</item>
+    <item msgid="6177579030803486015">"Երկար"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Արագ պատասխաններ"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Զանգեր"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Հաշիվներ զանգերի համար"</string>
diff --git a/res/values-in/strings.xml b/res/values-in/strings.xml
index add56a6..4f82757 100644
--- a/res/values-in/strings.xml
+++ b/res/values-in/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Nada dering ponsel"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Juga getar saat ada panggilan"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Nada tombol nomor"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Panjang nada tombol nomor"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Panjang"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respons cepat"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Panggilan telepon"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Akun panggilan"</string>
diff --git a/res/values-is-rIS/strings.xml b/res/values-is-rIS/strings.xml
index f226c33..a84b214 100644
--- a/res/values-is-rIS/strings.xml
+++ b/res/values-is-rIS/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Hringitónn síma"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Titra líka fyrir símtöl"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tónar takkaborðs"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Lengd takkatóns"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Venjulegur"</item>
+    <item msgid="6177579030803486015">"Langur"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Snarsvör"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Símtöl"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Símtalareikningar"</string>
diff --git a/res/values-it/strings.xml b/res/values-it/strings.xml
index 1e501da..fd0baf3 100644
--- a/res/values-it/strings.xml
+++ b/res/values-it/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Suoneria telefono"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrazione anche per chiamate"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Toni tastierino"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Durata tono tastierino"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normale"</item>
+    <item msgid="6177579030803486015">"Lunga"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Risposte rapide"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Chiamate"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Account chiamate"</string>
diff --git a/res/values-iw/strings.xml b/res/values-iw/strings.xml
index 0b54a7e..f8cbfb9 100644
--- a/res/values-iw/strings.xml
+++ b/res/values-iw/strings.xml
@@ -186,10 +186,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"רינגטון של טלפון"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"הפעל רטט גם עבור שיחות"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"צלילי לוח החיוג"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"אורך צליל של לוח חיוג"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"רגיל"</item>
+    <item msgid="6177579030803486015">"ארוך"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"תגובות מהירות"</string>
     <string name="call_settings_label" msgid="313434211353070209">"שיחות"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"חשבונות לביצוע שיחות"</string>
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
index 4b5f82a..4818608 100644
--- a/res/values-ja/strings.xml
+++ b/res/values-ja/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"、 "</string>
     <string name="display_options_title" msgid="7812852361055667468">"表示オプション"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"音とバイブレーション"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"ユーザー補助機能"</string>
     <string name="ringtone_title" msgid="760362035635084653">"着信音"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"着信時もバイブレーションON"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ダイヤルパッドの音"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ダイヤルパッドの音の長さ"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"標準"</item>
+    <item msgid="6177579030803486015">"長め"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"クイック返信"</string>
     <string name="call_settings_label" msgid="313434211353070209">"通話"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"通話アカウント"</string>
diff --git a/res/values-ka-rGE/strings.xml b/res/values-ka-rGE/strings.xml
index b97bc5f..d280a6e 100644
--- a/res/values-ka-rGE/strings.xml
+++ b/res/values-ka-rGE/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ეკრანის პარამეტრები"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"კინო და ვიბრაცია"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"მარტივი წვდომა"</string>
     <string name="ringtone_title" msgid="760362035635084653">"ტელეფონის ზარი"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"ზარებზე ასევე ვიბრირება"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ციფერბლატის ტონები"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ციფერბლატის ტონის ხანგრძლივობა"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"ჩვეულებრივი"</item>
+    <item msgid="6177579030803486015">"გრძელი"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"სწრაფი პასუხი"</string>
     <string name="call_settings_label" msgid="313434211353070209">"ზარები"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"ანგარიშების გამოძახება"</string>
diff --git a/res/values-kk-rKZ/strings.xml b/res/values-kk-rKZ/strings.xml
index 73a53ad..324ba8d 100644
--- a/res/values-kk-rKZ/strings.xml
+++ b/res/values-kk-rKZ/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Дисплей опциялары"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Дыбыстар мен діріл"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Арнайы мүмкіндіктер"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Телефон қоңырау әуені"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Сондай-ақ, қоңыраулар үшін дірілдету"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Теру тақтасының үндері"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Теру тақтасы дыбысының ұзындығы"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Қалыпты"</item>
+    <item msgid="6177579030803486015">"Ұзақ"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Жылдам жауаптар"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Қоңыраулар"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Есептік жазбаларға қоңыр. шалу"</string>
diff --git a/res/values-km-rKH/strings.xml b/res/values-km-rKH/strings.xml
index 04c342c..780b1de 100644
--- a/res/values-km-rKH/strings.xml
+++ b/res/values-km-rKH/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ជម្រើសបង្ហាញ"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"សម្លេង និងភាពរំញ័រ"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"លទ្ធភាពប្រើប្រាស់"</string>
     <string name="ringtone_title" msgid="760362035635084653">"សំឡេង​រោទ៍​ទូរស័ព្ទ"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"ញ័រ​សម្រាប់​ការ​ហៅ​ផងដែរ"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"សំឡេង​បន្ទះ​លេខ"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"រយៈពេលនៃសម្លេងបន្ទះលេខ"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"ធម្មតា"</item>
+    <item msgid="6177579030803486015">"វែង"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"ឆ្លើយតប​រហ័ស"</string>
     <string name="call_settings_label" msgid="313434211353070209">"ការហៅ"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"គណនីហៅទូរស័ព្ទ"</string>
diff --git a/res/values-kn-rIN/strings.xml b/res/values-kn-rIN/strings.xml
index 0829196..532fd90 100644
--- a/res/values-kn-rIN/strings.xml
+++ b/res/values-kn-rIN/strings.xml
@@ -181,15 +181,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ಪ್ರದರ್ಶನ ಆಯ್ಕೆಗಳು"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ಧ್ವನಿ ಮತ್ತು ವೈಬ್ರೇಷನ್‌"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"ಪ್ರವೇಶಿಸುವಿಕೆ"</string>
     <string name="ringtone_title" msgid="760362035635084653">"ಫೋನ್ ರಿಂಗ್‌ಟೋನ್"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"ಕರೆಗಳಿಗೂ ಸಹ ವೈಬ್ರೇಟ್‌"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ಡಯಲ್‌ಪ್ಯಾಡ್‌ ಧ್ವನಿಗಳು"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ಡಯಲ್‌ಪ್ಯಾಡ್‌ ಟೋನ್ ಅಳತೆ"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"ಸಾಮಾನ್ಯ"</item>
+    <item msgid="6177579030803486015">"ದೀರ್ಘವಾದ"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"ತ್ವರಿತ ಪ್ರತಿಕ್ರಿಯೆಗಳು"</string>
     <string name="call_settings_label" msgid="313434211353070209">"ಕರೆಗಳು"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"ಕರೆ ಮಾಡುವ ಖಾತೆಗಳು"</string>
diff --git a/res/values-ko/strings.xml b/res/values-ko/strings.xml
index d34e2d3..a70c4d7 100644
--- a/res/values-ko/strings.xml
+++ b/res/values-ko/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"표시 옵션"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"소리 및 진동"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"접근성"</string>
     <string name="ringtone_title" msgid="760362035635084653">"전화 벨소리"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"전화 올 때 벨소리와 함께 진동"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"다이얼패드 신호음"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"다이얼패드 신호음 길이"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"보통"</item>
+    <item msgid="6177579030803486015">"길게"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"빠른 응답"</string>
     <string name="call_settings_label" msgid="313434211353070209">"통화"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"통화 계정"</string>
diff --git a/res/values-ky-rKG/strings.xml b/res/values-ky-rKG/strings.xml
index 0cfe519..97ea976 100644
--- a/res/values-ky-rKG/strings.xml
+++ b/res/values-ky-rKG/strings.xml
@@ -207,15 +207,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Параметрлерди көрсөтүү"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Үндөр жана титирөө"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Жеткиликтүүлүк"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Телефондун шыңгыры"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Чалуулар үчүн дагы дирилдесин"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Тергичтин үндөрү"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Тергич обонунун узундугу"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Орточо"</item>
+    <item msgid="6177579030803486015">"Узун"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Тез жооптор"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Чалуулар"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Чалуу каттоо эсептери"</string>
diff --git a/res/values-lo-rLA/strings.xml b/res/values-lo-rLA/strings.xml
index 87543c9..b5c4359 100644
--- a/res/values-lo-rLA/strings.xml
+++ b/res/values-lo-rLA/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ຕົວເລືອກການສະແດງຜົນ"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ສຽງ ແລະ​ສັ່ນ"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"​ການ​ຊ່ວຍ​ເຂົ້າ​ເຖິງ"</string>
     <string name="ringtone_title" msgid="760362035635084653">"ຣິງໂທນໂທລະສັບ"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"ສັ່ນ​ເຕືອນ​ເມື່ອ​ມີ​ການ​ໂທ​ເຂົ້າ"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ສຽງ​ກົດ​ປຸ່ມ​ໂທ"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ຄວາມ​ຍາວ​ສຽງ​ແຜ່ນ​ກົດ"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"ປົກ​ກ​ະ​ຕິ"</item>
+    <item msgid="6177579030803486015">"ຍາວ"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"ການຕອບແບບວ່ອງໄວ"</string>
     <string name="call_settings_label" msgid="313434211353070209">"​ການ​ໂທ"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"ບັນ​ຊີ​ໂທ"</string>
diff --git a/res/values-lt/strings.xml b/res/values-lt/strings.xml
index af587b9..c25b942 100644
--- a/res/values-lt/strings.xml
+++ b/res/values-lt/strings.xml
@@ -186,10 +186,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Telefono skambėjimo tonas"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Taip pat vibruoti, kai skamb."</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Skambinimo skydelio garsai"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Skambinimo skydelio tono trukmė"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Įprastas"</item>
+    <item msgid="6177579030803486015">"Ilgas"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Greiti atsakai"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Skambučiai"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Skambinimo paskyros"</string>
diff --git a/res/values-lv/strings.xml b/res/values-lv/strings.xml
index 238075c..11c545d 100644
--- a/res/values-lv/strings.xml
+++ b/res/values-lv/strings.xml
@@ -185,10 +185,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Tālruņa zvana signāls"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Izmantot vibrozvanu zvaniem"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Numura sast. tastatūras toņi"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Numuru tastatūras signāla ilgums"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Parasts"</item>
+    <item msgid="6177579030803486015">"Ilgs"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Ātrās atbildes"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Zvani"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Zvanu konti"</string>
diff --git a/res/values-mk-rMK/strings.xml b/res/values-mk-rMK/strings.xml
index 0b4e77c..f9b9a9a 100644
--- a/res/values-mk-rMK/strings.xml
+++ b/res/values-mk-rMK/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Мелодија на телефон"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Вибрации и за повици"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Тонови на подлогата за бирање"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Должина на тонот на подлогата за бирање"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Нормално"</item>
+    <item msgid="6177579030803486015">"Долго"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Брзи одговори"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Повици"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Сметки за повикување"</string>
diff --git a/res/values-ml-rIN/strings.xml b/res/values-ml-rIN/strings.xml
index a4c2d15..73c3d26 100644
--- a/res/values-ml-rIN/strings.xml
+++ b/res/values-ml-rIN/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ഡിസ്‌പ്ലേ ഓപ്‌ഷനുകൾ"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ശബ്‌ദവും വൈബ്രേഷനും"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"പ്രവേശനക്ഷമത"</string>
     <string name="ringtone_title" msgid="760362035635084653">"ഫോൺ റിംഗ്ടോൺ"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"കോളുകൾക്കായും വൈബ്രേറ്റ് ചെയ്യും"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ഡയൽപാഡ് ടോണുകൾ"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ഡയൽപാഡ് ടോണിന്റെ ദൈർഘ്യം"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"സാധാരണം"</item>
+    <item msgid="6177579030803486015">"ദൈർഘ്യമുള്ളത്"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"ദ്രുത പ്രതികരണങ്ങൾ"</string>
     <string name="call_settings_label" msgid="313434211353070209">"കോളുകൾ"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"കോളുചെയ്യാനുള്ള അക്കൗണ്ട്"</string>
diff --git a/res/values-mn-rMN/strings.xml b/res/values-mn-rMN/strings.xml
index 8607462..67353fb 100644
--- a/res/values-mn-rMN/strings.xml
+++ b/res/values-mn-rMN/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Сонголтуудыг харуулах"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Дуу болон чичиргээ"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Хандалт"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Утасны хонхны ая"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Дуудлагад бас чичрэх"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Диалпадын ая"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Дугаар цуглуулах хэсгийн дохионы урт"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Энгийн"</item>
+    <item msgid="6177579030803486015">"Урт"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Шуурхай хариунууд"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Дуудлага"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Дуудах акаунт"</string>
diff --git a/res/values-mr-rIN/strings.xml b/res/values-mr-rIN/strings.xml
index 41e4a36..5da83d5 100644
--- a/res/values-mr-rIN/strings.xml
+++ b/res/values-mr-rIN/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"पर्याय प्रदर्शित करा"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ध्वनी आणि कंपने"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"प्रवेशयोग्यता"</string>
     <string name="ringtone_title" msgid="760362035635084653">"फोन रिंगटोन"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"कॉल साठी कंपन देखील करा"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"डायलपॅड टोन"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"डायलपॅड टोन लांबी"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"सामान्य"</item>
+    <item msgid="6177579030803486015">"लांब"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"द्रुत प्रतिसाद"</string>
     <string name="call_settings_label" msgid="313434211353070209">"कॉल"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"कॉल करण्याची खाती"</string>
diff --git a/res/values-ms-rMY/strings.xml b/res/values-ms-rMY/strings.xml
index 0a2017d..0c3d462 100644
--- a/res/values-ms-rMY/strings.xml
+++ b/res/values-ms-rMY/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Pilihan paparan"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Bunyi dan getaran"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Kebolehaksesan"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Nada dering telefon"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Juga bergetar untuk panggilan"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Nada pad dail"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Panjang nada pad dail"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Biasa"</item>
+    <item msgid="6177579030803486015">"Panjang"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respons pantas"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Panggilan"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Akaun panggilan"</string>
diff --git a/res/values-my-rMM/strings.xml b/res/values-my-rMM/strings.xml
index ecd39e2..30d8596 100644
--- a/res/values-my-rMM/strings.xml
+++ b/res/values-my-rMM/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"ဖုန်း သံစဉ်"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"ဖုန်းဝင်လျှင် တုန်ခါရန်"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ဖုန်းဒိုင်ခွက် အသံ"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"နံပါတ်ကွက် နှိပ်သံ ချိန်ညှိ"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"ပုံမှန်"</item>
+    <item msgid="6177579030803486015">"အရှည်"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"အမြန် တုံ့ပြန်ချက်များ"</string>
     <string name="call_settings_label" msgid="313434211353070209">"ခေါ်ဆိုမှုများ"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"ခေါ်ဆိုသော အကောင့်များ"</string>
diff --git a/res/values-nb/strings.xml b/res/values-nb/strings.xml
index 347bd5c..99a0fba 100644
--- a/res/values-nb/strings.xml
+++ b/res/values-nb/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Telefonringetone"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrer også når det ringer"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tastetoner for tastaturet"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Tonelengde for tastaturet"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Lang"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Hurtigsvar"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Anrop"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Ringe kontoer"</string>
diff --git a/res/values-ne-rNP/strings.xml b/res/values-ne-rNP/strings.xml
index e1c339a..374409a 100644
--- a/res/values-ne-rNP/strings.xml
+++ b/res/values-ne-rNP/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"फोन रिङटोन"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"कलका लागि कम्पन पनि गर्नुहोस्"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"डायलप्याड ध्वनि"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"डायलप्याड टोन लम्बाइ"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"सामान्य"</item>
+    <item msgid="6177579030803486015">"लामो"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"द्रुत प्रतिक्रियाहरू"</string>
     <string name="call_settings_label" msgid="313434211353070209">"कलहरू"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"खाता कलिङ"</string>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index d8986a6..be42a53 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Beltoon telefoon"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Ook trillen voor oproepen"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tonen bij toetsaanslag"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Toonduur toetsenblok"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normaal"</item>
+    <item msgid="6177579030803486015">"Lang"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Snelle reacties"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Oproepen"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Oproepaccounts"</string>
diff --git a/res/values-pl/strings.xml b/res/values-pl/strings.xml
index 2d1d38c..3dce5b4 100644
--- a/res/values-pl/strings.xml
+++ b/res/values-pl/strings.xml
@@ -186,10 +186,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Dzwonek telefonu"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Wibracja przy połączeniach"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Dźwięki klawiatury"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Tony klawiatury"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normalne"</item>
+    <item msgid="6177579030803486015">"Długie"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Szybkie odpowiedzi"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Połączenia"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Konta telefoniczne"</string>
diff --git a/res/values-pt-rPT/strings.xml b/res/values-pt-rPT/strings.xml
index 4ebd492..75752a0 100644
--- a/res/values-pt-rPT/strings.xml
+++ b/res/values-pt-rPT/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Toque do telemóvel"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrar também para chamadas"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tons do teclado"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Duração do tom do teclado"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Longa"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respostas rápidas"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Chamadas"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Contas de chamadas"</string>
diff --git a/res/values-pt/strings.xml b/res/values-pt/strings.xml
index 8019ef3..bc15cdd 100644
--- a/res/values-pt/strings.xml
+++ b/res/values-pt/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Toque do telefone"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Também vibrar para chamadas"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tons de teclado"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Duração do tom do teclado"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normais"</item>
+    <item msgid="6177579030803486015">"Longos"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Respostas rápidas"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Chamadas"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Contas de chamadas"</string>
diff --git a/res/values-ro/strings.xml b/res/values-ro/strings.xml
index a45e208..629a63f 100644
--- a/res/values-ro/strings.xml
+++ b/res/values-ro/strings.xml
@@ -181,15 +181,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Opțiuni de afișare"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Sunete și vibrații"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Accesibilitate"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Ton de apel al telefonului"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrează și pentru apeluri"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tonuri pt. tastatura numerică"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Lungimea tonului tastaturii numerice"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normală"</item>
+    <item msgid="6177579030803486015">"Lungă"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Răspunsuri rapide"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Apeluri"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Conturi pentru apelare"</string>
diff --git a/res/values-ru/strings.xml b/res/values-ru/strings.xml
index c5d77ce..4ead8e0 100644
--- a/res/values-ru/strings.xml
+++ b/res/values-ru/strings.xml
@@ -186,10 +186,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Рингтон"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Вибросигнал при вызове"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Звук при наборе номера"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Длительность сигналов при наборе номера"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Обычная"</item>
+    <item msgid="6177579030803486015">"Длинная"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Быстрые ответы"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Вызовы"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Аккаунты для звонков"</string>
diff --git a/res/values-si-rLK/strings.xml b/res/values-si-rLK/strings.xml
index ccfecba..61da82d 100644
--- a/res/values-si-rLK/strings.xml
+++ b/res/values-si-rLK/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"විකල්ප පෙන්වන්න"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ශබ්ද සහ කම්පන"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"ප්‍රවේශ්‍යතාවය"</string>
     <string name="ringtone_title" msgid="760362035635084653">"දුරකථන රිගින්ටෝනය"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"ඇමතුම් සඳහා කම්පනයද කරන්න"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ඩයල්පෑඩ ස්පර්ශක හඬ"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ඇමතුම් පෑඩයේ නාද දිග"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"සාමාන්‍ය"</item>
+    <item msgid="6177579030803486015">"දීර්ඝ"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"ක්ෂණික ප්‍රතිචාර"</string>
     <string name="call_settings_label" msgid="313434211353070209">"ඇමතුම්"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"ගිණුම් ඇමතීම"</string>
diff --git a/res/values-sk/strings.xml b/res/values-sk/strings.xml
index afb35b7..f7a2853 100644
--- a/res/values-sk/strings.xml
+++ b/res/values-sk/strings.xml
@@ -186,10 +186,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Tón zvonenia telefónu"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrovať aj pri hovoroch"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tóny číselnej klávesnice"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Dĺžka zvukov číselnej klávesnice"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normálne"</item>
+    <item msgid="6177579030803486015">"Dlhé"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Rýchle odpovede"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Hovory"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Telefónne účty"</string>
diff --git a/res/values-sl/strings.xml b/res/values-sl/strings.xml
index 20bf232..51948c2 100644
--- a/res/values-sl/strings.xml
+++ b/res/values-sl/strings.xml
@@ -186,10 +186,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Ton zvonjenja telefona"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibriranje tudi za klice"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Toni tipkovnice"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Dolžina pozivnih tonov"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Običajno"</item>
+    <item msgid="6177579030803486015">"Dolgo"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Hitri odgovori"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Klici"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Računi za klicanje"</string>
diff --git a/res/values-sr/strings.xml b/res/values-sr/strings.xml
index 60190ea..a3ac4dc 100644
--- a/res/values-sr/strings.xml
+++ b/res/values-sr/strings.xml
@@ -185,10 +185,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Звук звона телефона"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Вибрирај и за позиве"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Звуци нумеричке тастатуре"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Трајање тонова нумеричке тастатуре"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Нормално"</item>
+    <item msgid="6177579030803486015">"Дугачко"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Брзи одговори"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Позиви"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Налози за позивање"</string>
diff --git a/res/values-sv/strings.xml b/res/values-sv/strings.xml
index 59ce00c..9a82ada 100644
--- a/res/values-sv/strings.xml
+++ b/res/values-sv/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Ringsignal"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibrera också vid samtal"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Knappsatsljud"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Tonlängd för knappsats"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Lång"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Snabbsvar"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Samtal"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Konton för samtal"</string>
diff --git a/res/values-sw/strings.xml b/res/values-sw/strings.xml
index d5ee879..b0ab1ff 100644
--- a/res/values-sw/strings.xml
+++ b/res/values-sw/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Mlio wa simu"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Tetema simu zinapoingia pia"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Milio ya vitufe vya kupiga simu"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Urefu wa toni ya vitufe vya kupiga simu"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Kawaida"</item>
+    <item msgid="6177579030803486015">"Ndefu"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Majibu ya haraka"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Simu zilizopigwa"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Akaunti za simu"</string>
diff --git a/res/values-ta-rIN/strings.xml b/res/values-ta-rIN/strings.xml
index ff501fd..41a5c97 100644
--- a/res/values-ta-rIN/strings.xml
+++ b/res/values-ta-rIN/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"திரை விருப்பங்கள்"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"ஒலிகளும் அதிர்வும்"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"அணுகல் தன்மை"</string>
     <string name="ringtone_title" msgid="760362035635084653">"மொபைலின் ரிங்டோன்"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"அழைப்புகளுக்கும் அதிர்வுறு"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"டயல்பேட் ஒலிகள்"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"டயல்பேட் டோன் நீளம்"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"இயல்பு"</item>
+    <item msgid="6177579030803486015">"நீளமானது"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"விரைவு பதில்கள்"</string>
     <string name="call_settings_label" msgid="313434211353070209">"அழைப்புகள்"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"அழைப்பு கணக்குகள்"</string>
diff --git a/res/values-te-rIN/strings.xml b/res/values-te-rIN/strings.xml
index 6b80651..b0114d5 100644
--- a/res/values-te-rIN/strings.xml
+++ b/res/values-te-rIN/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"ఫోన్ రింగ్‌టోన్"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"కాల్‌ల కోసం వైబ్రేట్ కూడా చేయి"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"డయల్‌ప్యాడ్ టోన్‌లు"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"డయల్‌ప్యాడ్ టోన్ నిడివి"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"సాధారణం"</item>
+    <item msgid="6177579030803486015">"ఎక్కువ నిడివి"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"శీఘ్ర ప్రతిస్పందనలు"</string>
     <string name="call_settings_label" msgid="313434211353070209">"కాల్‌లు"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"కాల్ చేసే ఖాతాలు"</string>
diff --git a/res/values-th/strings.xml b/res/values-th/strings.xml
index 75717c0..b3423af 100644
--- a/res/values-th/strings.xml
+++ b/res/values-th/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ตัวเลือกการแสดง"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"เสียงและการสั่น"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"การเข้าถึง"</string>
     <string name="ringtone_title" msgid="760362035635084653">"เสียงเรียกเข้า"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"สั่นเมื่อมีสายเรียกเข้าด้วย"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"เสียงแป้นหมายเลข"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ระยะเวลาของเสียงแป้นหมายเลข"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"ปกติ"</item>
+    <item msgid="6177579030803486015">"ยาว"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"คำตอบด่วน"</string>
     <string name="call_settings_label" msgid="313434211353070209">"การโทร"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"บัญชีการโทร"</string>
diff --git a/res/values-tl/strings.xml b/res/values-tl/strings.xml
index 6573262..2ef0c26 100644
--- a/res/values-tl/strings.xml
+++ b/res/values-tl/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Mga opsyon sa pagpapakita"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Tunog at pag-vibrate"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Pagiging Naa-access"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Ringtone ng telepono"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Mag-vibrate din para sa tawag"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Mga dialpad tone"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Tagal ng tunog ng dialpad"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Mahaba"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Mga mabilisang tugon"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Mga Tawag"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Mga account sa pagtawag"</string>
diff --git a/res/values-tr/strings.xml b/res/values-tr/strings.xml
index 48e431e..702d42d 100644
--- a/res/values-tr/strings.xml
+++ b/res/values-tr/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Görüntüleme seçenekleri"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Ses ve titreşim"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Erişilebilirlik"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Telefon zil sesi"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Çağrılarda ayrıca titret"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tuş takımı tonları"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Tuş takımı ses uzunluğu"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normal"</item>
+    <item msgid="6177579030803486015">"Uzun"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Hızlı yanıtlar"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Çağrılar"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Çağrı hesapları"</string>
diff --git a/res/values-uk/strings.xml b/res/values-uk/strings.xml
index 5c3e980..2095b52 100644
--- a/res/values-uk/strings.xml
+++ b/res/values-uk/strings.xml
@@ -186,10 +186,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Сигнал дзвінка телефона"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Також вібрувати для дзвінків"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Звуки цифрової клавіатури"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Тривалість сигналу цифрової клавіатури"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Стандартний сигнал"</item>
+    <item msgid="6177579030803486015">"Довгий сигнал"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Швидкі відповіді"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Дзвінки"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Обл. записи для дзвінків"</string>
diff --git a/res/values-ur-rPK/strings.xml b/res/values-ur-rPK/strings.xml
index e4ed9bf..4e9097e 100644
--- a/res/values-ur-rPK/strings.xml
+++ b/res/values-ur-rPK/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"، "</string>
     <string name="display_options_title" msgid="7812852361055667468">"ڈسپلے کے اختیارات"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"آوازیں اور وائبریشن"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Accessibility"</string>
     <string name="ringtone_title" msgid="760362035635084653">"فون رِنگ ٹون"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"کالز کیلئے وائبریٹ بھی کرے"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"ڈائل پیڈ ٹونز"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"ڈائل پیڈ ٹون کی لمبائی"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"حسب معمول"</item>
+    <item msgid="6177579030803486015">"طویل"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"فوری جوابات"</string>
     <string name="call_settings_label" msgid="313434211353070209">"کالز"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"کالنگ اکاؤنٹس"</string>
diff --git a/res/values-uz-rUZ/strings.xml b/res/values-uz-rUZ/strings.xml
index 52199f6..ead63d8 100644
--- a/res/values-uz-rUZ/strings.xml
+++ b/res/values-uz-rUZ/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Ko‘rsatish sozlamalari"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Ovozlar va tebranish"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Maxsus imkoniyatlar"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Telefon uchun rington"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Qo‘ng‘iroq vaqtida tebranish"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Tugmalar tovushi"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Klaviatura ohangi uzunligi"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"O‘rtacha"</item>
+    <item msgid="6177579030803486015">"Uzun"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Tezkor javoblar"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Qo‘ng‘iroqlar"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Qo‘ng‘iroq uchun hisoblar"</string>
diff --git a/res/values-vi/strings.xml b/res/values-vi/strings.xml
index 744086f..99b5ffb 100644
--- a/res/values-vi/strings.xml
+++ b/res/values-vi/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">", "</string>
     <string name="display_options_title" msgid="7812852361055667468">"Tùy chọn hiển thị"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"Âm thanh và rung"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Trợ năng"</string>
     <string name="ringtone_title" msgid="760362035635084653">"Nhạc chuông điện thoại"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Đồng thời rung khi có cuộc gọi"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Âm bàn phím số"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Độ dài âm bàn phím số"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Thường"</item>
+    <item msgid="6177579030803486015">"Dài"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Trả lời nhanh"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Cuộc gọi"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Tài khoản gọi"</string>
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index 36925d8..537c6b1 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"、 "</string>
     <string name="display_options_title" msgid="7812852361055667468">"显示选项"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"提示音和振动"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"无障碍功能"</string>
     <string name="ringtone_title" msgid="760362035635084653">"手机铃声"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"有来电时响铃并振动"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"拨号键盘提示音"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"拨号键盘提示音长度"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"标准"</item>
+    <item msgid="6177579030803486015">"长"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"快速回复"</string>
     <string name="call_settings_label" msgid="313434211353070209">"通话"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"通话帐户"</string>
diff --git a/res/values-zh-rHK/strings.xml b/res/values-zh-rHK/strings.xml
index f5a885b..8485784 100644
--- a/res/values-zh-rHK/strings.xml
+++ b/res/values-zh-rHK/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"、 "</string>
     <string name="display_options_title" msgid="7812852361055667468">"顯示選項"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"聲音和震動"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"無障礙功能"</string>
     <string name="ringtone_title" msgid="760362035635084653">"手機鈴聲"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"來電時同時震動"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"撥號盤音效"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"撥號音長度"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"正常"</item>
+    <item msgid="6177579030803486015">"長"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"快速回應"</string>
     <string name="call_settings_label" msgid="313434211353070209">"通話"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"通話帳戶"</string>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index bb57f84..93f3e31 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -180,15 +180,15 @@
     <string name="list_delimeter" msgid="4571593167738725100">"、 "</string>
     <string name="display_options_title" msgid="7812852361055667468">"顯示選項"</string>
     <string name="sounds_and_vibration_title" msgid="1692290115642160845">"音效與振動"</string>
-    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
-    <skip />
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"協助工具"</string>
     <string name="ringtone_title" msgid="760362035635084653">"手機鈴聲"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"來電時同時震動"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"撥號鍵盤音效"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"撥號鍵盤聲調長度"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"一般"</item>
+    <item msgid="6177579030803486015">"長"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"快速回應"</string>
     <string name="call_settings_label" msgid="313434211353070209">"通話"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"通話帳戶"</string>
diff --git a/res/values-zu/strings.xml b/res/values-zu/strings.xml
index e20ab8a..d3a5ff8 100644
--- a/res/values-zu/strings.xml
+++ b/res/values-zu/strings.xml
@@ -184,10 +184,11 @@
     <string name="ringtone_title" msgid="760362035635084653">"Ithoni yokukhala yefoni"</string>
     <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Iyadlidliza futhi ngamakholi"</string>
     <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Ukukhala kwephedi yokudayela"</string>
-    <!-- no translation found for dtmf_tone_length_title (8581125689808919460) -->
-    <skip />
-    <!-- no translation found for dtmf_tone_length_entries:0 (1036113889050195575) -->
-    <!-- no translation found for dtmf_tone_length_entries:1 (6177579030803486015) -->
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Ubude bethoni bephedi yokudayela"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Okujwayelekile"</item>
+    <item msgid="6177579030803486015">"Kude"</item>
+  </string-array>
     <string name="respond_via_sms_setting_title" msgid="1318281521087951580">"Izimpendulo ezisheshayo"</string>
     <string name="call_settings_label" msgid="313434211353070209">"Amakholi"</string>
     <string name="phone_account_settings_label" msgid="5864322009841175294">"Ama-akhawunti wokushaya"</string>
