diff --git a/res/values-ar/arrays.xml b/res/values-ar/arrays.xml
index a0f166d..73b4350 100644
--- a/res/values-ar/arrays.xml
+++ b/res/values-ar/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"يتم عرض بعض الرسوم المتحركة للنافذة"</item>
     <item msgid="488968798204105119">"يتم عرض جميع الرسوم المتحركة للنافذة"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 ثانية"</item>
-    <item msgid="8881760709354815449">"30 ثانية"</item>
-    <item msgid="7589406073232279088">"دقيقة واحدة"</item>
-    <item msgid="7001195990902244174">"2 دقائق"</item>
-    <item msgid="5721688686241190620">"10 دقائق"</item>
-    <item msgid="7156442995039264948">"30 دقيقة"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"بطيء للغاية"</item>
     <item msgid="2361722960903353554">"بطيء"</item>
diff --git a/res/values-ar/strings.xml b/res/values-ar/strings.xml
index 8939289..a1d4c6a 100644
--- a/res/values-ar/strings.xml
+++ b/res/values-ar/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"منتقي جهاز البلوتوث"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"طلب إذن بلوتوث"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"يطلب أحد التطبيقات في هاتفك إذنًا بتشغيل البلوتوث. هل تريد إجراء ذلك؟"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"يطلب أحد تطبيقات هاتفك إذنًا لجعل هاتفك قابلاً للاكتشاف بواسطة أجهزة البلوتوث الأخرى لمدة <xliff:g id="TIMEOUT">%1$d</xliff:g> ثانية. هل تريد إجراء ذلك؟"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"يطلب أحد تطبيقات هاتفك إذنًا لجعل هاتفك قابلاً للاكتشاف بواسطة أجهزة البلوتوث الأخرى لمدة <xliff:g id="TIMEOUT">%1$d</xliff:g> ثانية. هل تريد إجراء ذلك؟"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"يطلب أحد تطبيقات هاتفك إذنًا لتشغيل البلوتوث وجعل هاتفك قابل للاكتشاف بواسطة أجهزة بلوتوث أخرى لمدة <xliff:g id="TIMEOUT">%1$d</xliff:g> ثانية. هل تريد إجراء ذلك؟"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"يطلب أحد تطبيقات هاتفك إذنًا لتشغيل البلوتوث وجعل هاتفك قابل للاكتشاف بواسطة أجهزة بلوتوث أخرى لمدة <xliff:g id="TIMEOUT">%1$d</xliff:g> ثانية. هل تريد إجراء ذلك؟"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"جارٍ تشغيل البلوتوث..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"إعدادات التاريخ والوقت"</string>
@@ -856,7 +858,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"جارٍ التحميل…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"معلومات الأمان"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"معلومات الأمان"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"هاتفك غير متصل بخدمة البيانات. لعرض هذه المعلومات الآن، انتقل إلى % من أي جهاز كمبيوتر متصل بالإنترنت."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"جارٍ التحميل…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"اختيار كلمة المرور"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"اختيار رقم التعريف الشخصي"</string>
@@ -1005,12 +1008,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"تم البدء بواسطة التطبيق: المس للإيقاف"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-bg/arrays.xml b/res/values-bg/arrays.xml
index a3ea551..37967b0 100644
--- a/res/values-bg/arrays.xml
+++ b/res/values-bg/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Показват се някои анимации на прозорци"</item>
     <item msgid="488968798204105119">"Показват се всички анимации на прозорци"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 секунди"</item>
-    <item msgid="8881760709354815449">"30 секунди"</item>
-    <item msgid="7589406073232279088">"1 минута"</item>
-    <item msgid="7001195990902244174">"2 минути"</item>
-    <item msgid="5721688686241190620">"10 минути"</item>
-    <item msgid="7156442995039264948">"30 минути"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Много бавна"</item>
     <item msgid="2361722960903353554">"Бавна"</item>
diff --git a/res/values-bg/strings.xml b/res/values-bg/strings.xml
index a70cad0..507b64d 100644
--- a/res/values-bg/strings.xml
+++ b/res/values-bg/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Избиране на Bluetooth устройство"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Заявка за разрешение на Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Приложение от телефона ви иска разрешение да включи Bluetooth. Искате ли да направите това?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Приложение от телефона ви иска разрешение да го направи откриваем от други Bluetooth устройства за <xliff:g id="TIMEOUT">%1$d</xliff:g> секунди. Искате ли да направите това?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Приложение от телефона ви иска разрешение да го направи откриваем от други Bluetooth устройства за <xliff:g id="TIMEOUT">%1$d</xliff:g> секунди. Искате ли да направите това?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Приложение от телефона ви иска разрешение да включи Bluetooth и да го направи откриваем от други Bluetooth устройства за <xliff:g id="TIMEOUT">%1$d</xliff:g> секунди. Искате ли да направите това?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Приложение от телефона ви иска разрешение да включи Bluetooth и да го направи откриваем от други Bluetooth устройства за <xliff:g id="TIMEOUT">%1$d</xliff:g> секунди. Искате ли да направите това?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Bluetooth се включва..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"Настройки за дата и час"</string>
@@ -863,7 +865,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Зарежда се…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Информация за безопасност"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Информация за безопасност"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Телефонът ви не е свързан с услуга за данни. За да видите тази информация сега, посетете %s от всеки компютър, свързан с интернет."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Зарежда се…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Изберете паролата си"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Изберете своя PIN"</string>
@@ -1012,12 +1015,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Започната от приложение: докоснете за спиране"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-ca/arrays.xml b/res/values-ca/arrays.xml
index eb6bbab..38b8988 100644
--- a/res/values-ca/arrays.xml
+++ b/res/values-ca/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Es mostren algunes animacions de finestres"</item>
     <item msgid="488968798204105119">"Es mostren totes les animacions de finestres"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 segons"</item>
-    <item msgid="8881760709354815449">"30 segons"</item>
-    <item msgid="7589406073232279088">"1 minut"</item>
-    <item msgid="7001195990902244174">"2 minuts"</item>
-    <item msgid="5721688686241190620">"10 minuts"</item>
-    <item msgid="7156442995039264948">"30 minuts"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Molt lenta"</item>
     <item msgid="2361722960903353554">"Lenta"</item>
diff --git a/res/values-ca/strings.xml b/res/values-ca/strings.xml
index f989e21..d96f829 100644
--- a/res/values-ca/strings.xml
+++ b/res/values-ca/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Selector de dispositiu Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Sol·licitud de permís de Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Una aplicació del telèfon sol·licita permís per activar el Bluetooth. Voleu permetre-ho?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Una aplicació del telèfon sol·licita permís per permetre que altres dispositius Bluetooth puguin detectar el telèfon durant <xliff:g id="TIMEOUT">%1$d</xliff:g> segons. Voleu permetre-ho?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Una aplicació del telèfon sol·licita permís per permetre que altres dispositius Bluetooth puguin detectar el telèfon durant <xliff:g id="TIMEOUT">%1$d</xliff:g> segons. Voleu permetre-ho?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Una aplicació del telèfon sol·licita permís per activar el Bluetooth i perquè altres dispositius puguin detectar el telèfon durant <xliff:g id="TIMEOUT">%1$d</xliff:g> segons. Voleu permetre-ho?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Una aplicació del telèfon sol·licita permís per activar el Bluetooth i perquè altres dispositius puguin detectar el telèfon durant <xliff:g id="TIMEOUT">%1$d</xliff:g> segons. Voleu permetre-ho?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"S\'està activant Bluetooth..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"Configuració de data i hora"</string>
@@ -863,7 +865,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"S\'està carregant…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informació de seguretat"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informació de seguretat"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"El telèfon no està connectat a un servei de dades. Per visualitzar aquesta informació ara, aneu a %s des de qualsevol equip connectat a Internet."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"S\'està carregant…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Trieu la contrasenya"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Selecció del PIN"</string>
@@ -1012,12 +1015,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Iniciat per l\'aplicació: toqueu per aturar-lo"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-cs/arrays.xml b/res/values-cs/arrays.xml
index b156b56..dbadbdf 100644
--- a/res/values-cs/arrays.xml
+++ b/res/values-cs/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"Zobrazují se některé animace oken"</item>
     <item msgid="488968798204105119">"Zobrazují se všechny animace oken"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 sekund"</item>
-    <item msgid="8881760709354815449">"30 sekund"</item>
-    <item msgid="7589406073232279088">"1 minuta"</item>
-    <item msgid="7001195990902244174">"2 minuty"</item>
-    <item msgid="5721688686241190620">"10 minut"</item>
-    <item msgid="7156442995039264948">"30 min."</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"okamžitě"</item>
-    <item msgid="6736512735606834431">"5 sekund"</item>
-    <item msgid="8044619388267891375">"15 sekund"</item>
-    <item msgid="1822002388249545488">"30 sekund"</item>
-    <item msgid="8538071621211916519">"1 minuta"</item>
-    <item msgid="5663439580228932882">"2 minuty"</item>
-    <item msgid="7505084444184116101">"10 minut"</item>
-    <item msgid="4621683909972069205">"30 minut"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Velmi pomalá"</item>
     <item msgid="2361722960903353554">"Pomalá"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Nikdy, je-li zapnuto napájení"</item>
     <item msgid="1986753720941888596">"Nikdy"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Automaticky"</item>
+    <item msgid="6670588712989942178">"Pouze 5 GHz"</item>
+    <item msgid="2715516524973207876">"Pouze 2,4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Doba použití"</item>
     <item msgid="1908750532762193304">"Počet spuštění"</item>
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index 6c15938..7942955 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Výběr zařízení Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Požadavek na povolení zařízení Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Aplikace v telefonu požaduje povolení zapnout připojení Bluetooth. Chcete toto povolení udělit?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Aplikace v telefonu požaduje povolení nastavit telefon do viditelného režimu na <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Chcete toto povolení udělit?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Aplikace v telefonu požaduje povolení nastavit telefon do viditelného režimu na <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Chcete toto povolení udělit?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Aplikace v telefonu požaduje povolení zapnout připojení Bluetooth a nastavit telefonu do viditelného režimu na <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Chcete toto povolení udělit?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Aplikace v telefonu požaduje povolení zapnout připojení Bluetooth a nastavit telefonu do viditelného režimu na <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Chcete toto povolení udělit?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Zapínání zařízení Bluetooth..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"Nastavení data a času"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Zásady používání sítě Wi-Fi v režimu spánku"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Určit, kdy přepnout ze sítě Wi-Fi na mobilní datový přenos"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Při nastavení zásad pro režim spánku došlo k problému."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Frekvenční pásmo Wi-Fi"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Uveďte provozní frekvenční rozsah"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Při nastavení frekvenčního pásma došlo k problému."</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Adresa MAC"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Adresa IP"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"Nastavení adresy IP"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"Připojit kartu SD"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Smazat úložiště USB"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"Smazat kartu SD"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Smaže všechna data v interním úložišti USB telefonu, například hudbu a fotografie"</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Smaže všechna data v interním úložišti USB, například hudbu a fotografie"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Smaže všechna data v interním úložišti USB telefonu, například hudbu a fotografie"</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"Nedostupný údaj"</string>
     <string name="read_only" msgid="6702420168629076340">" (Pouze pro čtení)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Obnovení továrních dat"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Vymaže všechna data v telefonu"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Vymaže všechna data v telefonu"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Tato operace vymaže všechna data v "<b>"interním úložišti"</b>" tabletu, včetně:"\n\n<li>"účtu Google,"</li>\n<li>"dat a nastavení aplikací a systému,"</li>\n<li>"stažených aplikací."</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Tato operace vymaže všechna data v "<b>"interním úložišti"</b>" telefonu, včetně:"\n\n<li>"účtu Google,"</li>\n<li>"dat a nastavení systému a aplikací,"</li>\n<li>"stažených aplikací."</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Aktuálně jste přihlášeni do následujících účtů:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Chcete-li smazat také hudbu, obrázky a další uživatelská data, je potřeba vymazat "<b>"úložiště USB"</b>"."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Smazat úložiště USB"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Smazat kartu SD"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Smazat všechna data v interním úložišti USB telefonu, například hudbu a fotografie."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Smazat všechna data v interním úložišti USB telefonu, například hudbu a fotografie."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Smazat všechna data v interním úložišti USB, například hudbu a fotografie."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Smazat všechna data na kartě SD, například hudbu a fotografie."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Resetovat telefon"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Resetovat telefon"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"Chcete smazat všechny osobní informace a stažené aplikace? Tuto akci nelze vrátit zpět."</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Proveďte gesto odemknutí"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Chcete-li potvrdit reset telefonu, musíte provést gesto odemknutí."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"Pokus o reset se nezdařil, protože služba System Clear není dostupná."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Potvrdit resetování"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Smazat úložiště USB"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"Smazat kartu SD"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Smaže data v úložišti USB"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Použít systém A-GPS"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"Vylepšit funkčnost GPS pomocí serveru (deaktivací této funkce snížíte využití sítě)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"Vylepšit funkčnost GPS pomocí serveru (zrušením této funkce zvýšíte výkon GPS)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"Používat funkci Moje poloha"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Používat polohu pro vyhledávání Google"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Používat polohu pro vyhledávání Google a další služby Google"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"Ke zlepšení výsledků vyhledávání Google a dalších služeb Google se využívají informace o poloze"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"Info o telefonu"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"Info o telefonu"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Zobrazuje právní informace, stav telefonu a verzi softwaru"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Načítání..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Bezpečnostní informace"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Bezpečnostní informace"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Telefon není připojen k datové službě. Chcete-li tyto informace zobrazit nyní, přejděte na stránku %s z libovolného počítače připojeného k internetu."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Načítání..."</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Zvolte heslo"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Zvolte kód PIN"</string>
diff --git a/res/values-da/arrays.xml b/res/values-da/arrays.xml
index 7053419..3ce8428 100644
--- a/res/values-da/arrays.xml
+++ b/res/values-da/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"Der vises nogle vinduesanimationer"</item>
     <item msgid="488968798204105119">"Alle vinduesanimationer vises"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 sekunder"</item>
-    <item msgid="8881760709354815449">"30 sekunder"</item>
-    <item msgid="7589406073232279088">"1 minut"</item>
-    <item msgid="7001195990902244174">"2 minutter"</item>
-    <item msgid="5721688686241190620">"10 minutter"</item>
-    <item msgid="7156442995039264948">"30 minutter"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"med det samme"</item>
-    <item msgid="6736512735606834431">"5 sekunder"</item>
-    <item msgid="8044619388267891375">"15 sekunder"</item>
-    <item msgid="1822002388249545488">"30 sekunder"</item>
-    <item msgid="8538071621211916519">"1 minut"</item>
-    <item msgid="5663439580228932882">"2 minutter"</item>
-    <item msgid="7505084444184116101">"10 minutter"</item>
-    <item msgid="4621683909972069205">"30 minutter"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Meget langsom"</item>
     <item msgid="2361722960903353554">"Langsom"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Aldrig når tilsluttet"</item>
     <item msgid="1986753720941888596">"Aldrig"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Automatisk"</item>
+    <item msgid="6670588712989942178">"Kun 5 GHz"</item>
+    <item msgid="2715516524973207876">"Kun 2,4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Brugstid"</item>
     <item msgid="1908750532762193304">"Start optælling"</item>
diff --git a/res/values-da/strings.xml b/res/values-da/strings.xml
index 78fe230..e10974b 100644
--- a/res/values-da/strings.xml
+++ b/res/values-da/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Vælger af Bluetooth-enheder"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Anmodning om Bluetooth-tilladelse"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Et program på din telefon anmoder om at aktivere Bluetooth. Ønsker du at gøre dette?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Et program på din telefon kræver tilladelse til, at din telefon er synlig for andre Bluetooth-enheder i <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunder. Ønsker du at gøre dette?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Et program på din telefon kræver tilladelse til, at din telefon er synlig for andre Bluetooth-enheder i <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunder. Ønsker du at gøre dette?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Et program på din telefon anmoder om tilladelse til at aktivere Bluetooth, så din telefon er synlig for andre enheder i <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunder. Ønsker du at gøre dette?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Et program på din telefon anmoder om tilladelse til at aktivere Bluetooth, så din telefon er synlig for andre enheder i <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunder. Ønsker du at gøre dette?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Aktiverer Bluetooth …"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Indstillinger for dato og tid"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Politik for Wi-Fi-dvale"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Angiv, hvornår der skal skiftes fra Wi-Fi til mobile data"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Der opstod et problem med indstillingen af dvalepolitikken."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Wi-Fi-frekvensbånd"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Angiv frekvensintervallet"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Problemer med indstillingen af frekvensbåndet."</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MAC-adresse"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP-adresse"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"IP-indstillinger"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"Montér SD-kortet"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Slet USB-lager"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"Slet SD-kort"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Sletter alle data på telefonens interne USB-lager, f.eks. musik og billeder."</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Sletter alle data på det interne USB-lager, f.eks. musik og billeder"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Sletter alle data på telefonens interne USB-lager, f.eks. musik og billeder."</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"Utilgængelig"</string>
     <string name="read_only" msgid="6702420168629076340">" (Skrivebeskyttet)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Gendannelse af fabriksdata"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Sletter alle data på telefonen"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Sletter alle data på telefonen"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Dette sletter alle data fra tablettens "<b>"interne lager"</b>", bl.a.:"\n\n<li>"din Google-konto"</li>\n<li>"system- og programdata og -indstillinger"</li>\n<li>"downloadede programmer"</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Dette sletter alle data fra telefonens "<b>"interne lager"</b>", bl.a.:"\n\n<li>"din Google-konto"</li>\n<li>"system- og programdata og -indstillinger"</li>\n<li>"downloadede programmer"</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Du er i øjeblikket logget ind på disse konti:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Ryd også musik, billeder og andre brugerdata ved også at slette "<b>"USB-lager"</b>"."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Slet USB-lager"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Slet SD-kort"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Slet alle data på telefonens interne USB-lager, f.eks. musik og billeder."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Slet alle data på telefonens interne USB-lager, f.eks. musik og billeder."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Slet alle data på det interne USB-lager, f.eks. musik og billeder."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Slet alle data på SD-kortet, f.eks. musik og billeder."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Nulstil telefon"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Nulstil telefon"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"Slet alle dine personlige oplysninger og downloadede programmer? Denne handlíng kan ikke fortrydes."</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Tegn dit oplåsningsmønster"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Du skal tegne dit oplåsningsmønster for at bekræfte, at telefonen nulstilles."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"Der blev ikke foretaget nogen nulstilling, fordi tjenesten Systemoprydning ikke er tilgængelig."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Bekræft nulstilling"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Slet USB-lager"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"Slet SD-kort"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Sletter alle data i USB-lager"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Brug assisteret GPS"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"Brug serveren til at assistere GPS (fjern markering for at mindske netværksforbrug)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"Brug serveren til at assistere GPS (fjern markering for at forbedre GPS-ydelsen)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"Brug Min placering"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Brug placering ved Google-søgning"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Brug placering til Google-søgning og andre Google-tjenester"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"Placering bruges til at forbedre Google-søgeresultater og andre Google-tjenester"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"Om telefonen"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"Om telefonen"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Vis juridiske oplysninger, telefonstatus, softwareversion"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Indlæser ..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Sikkerhedsoplysninger"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Sikkerhedsoplysninger"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Din telefon er ikke tilsluttet en datatjeneste. For at se disse oplysninger nu skal du gå til  %s fra en hvilken som helst computer, der er forbundet til internettet."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Indlæser ..."</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Vælg din adgangskode"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Vælg din pinkode"</string>
diff --git a/res/values-de/arrays.xml b/res/values-de/arrays.xml
index 519f8f3..132b823 100644
--- a/res/values-de/arrays.xml
+++ b/res/values-de/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"Einige Fensteranimationen werden angezeigt."</item>
     <item msgid="488968798204105119">"Alle Fensteranimationen werden angezeigt."</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 Sekunden"</item>
-    <item msgid="8881760709354815449">"30 Sekunden"</item>
-    <item msgid="7589406073232279088">"1 Minute"</item>
-    <item msgid="7001195990902244174">"2 Minuten"</item>
-    <item msgid="5721688686241190620">"10 Minuten"</item>
-    <item msgid="7156442995039264948">"30 Minuten"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"sofort"</item>
-    <item msgid="6736512735606834431">"5 Sekunden"</item>
-    <item msgid="8044619388267891375">"15 Sekunden"</item>
-    <item msgid="1822002388249545488">"30 Sekunden"</item>
-    <item msgid="8538071621211916519">"1 Minute"</item>
-    <item msgid="5663439580228932882">"2 Minuten"</item>
-    <item msgid="7505084444184116101">"10 Minuten"</item>
-    <item msgid="4621683909972069205">"30 Minuten"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Sehr langsam"</item>
     <item msgid="2361722960903353554">"Langsam"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Niemals, wenn im Netzbetrieb"</item>
     <item msgid="1986753720941888596">"Niemals"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Automatisch"</item>
+    <item msgid="6670588712989942178">"Nur 5 GHz"</item>
+    <item msgid="2715516524973207876">"Nur 2,4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Nutzungszeit"</item>
     <item msgid="1908750532762193304">"Startzähler"</item>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index 38caafa..2c04fdc 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Bluetooth-Geräteauswahl"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Bluetooth-Berechtigungsanfrage"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Eine Anwendung auf Ihrem Telefon beantragt eine Berechtigung zum Aktivieren von Bluetooth. Möchten Sie dies tun?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Eine Anwendung auf Ihrem Telefon beantragt die Berechtigung, Ihr Telefon für <xliff:g id="TIMEOUT">%1$d</xliff:g> Sekunden für andere Bluethooth-Geräte sichtbar zu machen. Möchten Sie dies tun?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Eine Anwendung auf Ihrem Telefon beantragt die Berechtigung, Ihr Telefon für <xliff:g id="TIMEOUT">%1$d</xliff:g> Sekunden für andere Bluethooth-Geräte sichtbar zu machen. Möchten Sie dies tun?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Eine Anwendung auf Ihrem Telefon beantragt die Berechtigung, Bluetooth zu aktivieren und Ihr Telefon für <xliff:g id="TIMEOUT">%1$d</xliff:g> Sekunden für andere Telefone sichtbar zu machen. Möchten Sie dies tun?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Eine Anwendung auf Ihrem Telefon beantragt die Berechtigung, Bluetooth zu aktivieren und Ihr Telefon für <xliff:g id="TIMEOUT">%1$d</xliff:g> Sekunden für andere Telefone sichtbar zu machen. Möchten Sie dies tun?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Bluetooth wird aktiviert..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"Einstellungen"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"WLAN Standby-Richtlinie"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Festlegen, wann von WLAN auf mobile Daten umgeschaltet werden soll"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Beim Einrichten der Standby-Richtlinie ist ein Problem aufgetreten."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"WLAN-Frequenzband"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Frequenzbereich für Betrieb festlegen"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Fehler beim Festlegen des Frequenzbands"</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MAC-Adresse"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP-Adresse"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"IP-Einstellungen"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"SD-Karte bereitstellen"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"USB-Speicher löschen"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"SD-Karte löschen"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Löscht alle Daten, z. B. Musik und Fotos, aus d. int. USB-Speicher d. Telefons"</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Löscht alle Daten, z. B. Musik und Fotos, aus dem internen USB-Speicher"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Löscht alle Daten, z. B. Musik und Fotos, aus d. int. USB-Speicher d. Telefons"</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"Nicht verfügbar"</string>
     <string name="read_only" msgid="6702420168629076340">" (schreibgeschützt)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Auf Werkszustand zurück"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Löscht alle Daten auf dem Telefon"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Löscht alle Daten auf dem Telefon"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Hierdurch werden alle Daten aus dem "<b>"internen Speicher"</b>" Ihres Tablet-Geräts gelöscht, u. a."\n\n<li>"Ihr Google-Konto,"</li>\n<li>"die System- und Anwendungsdaten und -einstellungen"</li>\n<li>"und heruntergeladene Anwendungen"</li>"."</string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Hierdurch werden alle Daten aus dem "<b>"internen Speicher"</b>" Ihres Telefons gelöscht, u. a."\n\n<li>"Ihr Google-Konto,"</li>\n<li>"die System- und Anwendungsdaten und -einstellungen"</li>\n<li>"und heruntergeladene Anwendungen"</li>"."</string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Sie sind derzeit in folgenden Konten angemeldet:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Um auch Musik, Bilder und sonstige Nutzerdaten zu löschen, muss der "<b>"USB-Speicher"</b>" geleert werden."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"USB-Speicher löschen"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"SD-Karte löschen"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Löscht alle Daten, z. B. Musik und Fotos, aus dem int. USB-Speicher des Telefons"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Löscht alle Daten, z. B. Musik und Fotos, aus dem int. USB-Speicher des Telefons"</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Löscht alle Daten, z. B. Musik und Fotos, aus dem internen USB-Speicher"</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Alle Daten, z. B. Musik und Fotos, von der SD-Karte löschen"</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Telefon zurücksetzen"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Telefon zurücksetzen"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"Alle persönlichen Daten und heruntergeladenen Anwendungen löschen? Diese Aktion kann nicht rückgängig gemacht werden."</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Bitte zeichnen Sie Ihr Entsperrungsmuster."</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Sie müssen Ihr Entsperrungsmuster eingeben, um das Zurücksetzen des Telefons zu bestätigen."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"Die Zurücksetzung konnte nicht durchgeführt werden, da der Service zur Systembereinigung nicht verfügbar ist."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Zurücksetzen bestätigen"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"USB-Speicher löschen"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"SD-Karte löschen"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Löscht alles im USB-Speicher."</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Unterstütztes GPS verwenden"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"Server zur Unterstützung von GPS verwenden (zur Verringerung der Netzwerkauslastung nicht auswählen)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"Server zur Unterstützung von GPS verwenden (zur Verbesserung der GPS-Leistung deaktivieren)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"Standort verwenden"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Standort für Google-Suche verwenden"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Standort für Google-Suche und andere Google-Services verwenden"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"Standort für Google-Suchergebnisse/-Services verwendet"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"Telefoninfo"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"Telefoninfo"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Rechtliche Hinweise, Telefonstatus und Softwareversion anzeigen"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Wird geladen..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Sicherheitsinformationen"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Sicherheitsinformationen"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Ihr Telefon ist mit keinem Datendienst verbunden. Um diese Informationen jetzt anzuzeigen, rufen Sie %s von einem beliebigen, mit dem Internet verbundenen Computer auf."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Wird geladen..."</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Passwort auswählen"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"PIN auswählen"</string>
diff --git a/res/values-el/arrays.xml b/res/values-el/arrays.xml
index 4d4d525..e6ac187 100644
--- a/res/values-el/arrays.xml
+++ b/res/values-el/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"Εμφάνιση ορισμένων εφέ κίνησης παραθύρων"</item>
     <item msgid="488968798204105119">"Εμφανίζονται όλα τα εφέ κίνησης παραθύρων"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 δευτερόλεπτα"</item>
-    <item msgid="8881760709354815449">"30 δευτερόλεπτα"</item>
-    <item msgid="7589406073232279088">"1 λεπτό"</item>
-    <item msgid="7001195990902244174">"2 λεπτά"</item>
-    <item msgid="5721688686241190620">"10 λεπτά"</item>
-    <item msgid="7156442995039264948">"30 λεπτά"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"άμεσα"</item>
-    <item msgid="6736512735606834431">"5 δευτερόλεπτα"</item>
-    <item msgid="8044619388267891375">"15 δευτερόλεπτα"</item>
-    <item msgid="1822002388249545488">"30 δευτερόλεπτα"</item>
-    <item msgid="8538071621211916519">"1 λεπτό"</item>
-    <item msgid="5663439580228932882">"2 λεπτά"</item>
-    <item msgid="7505084444184116101">"10 λεπτά"</item>
-    <item msgid="4621683909972069205">"30 λεπτά"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Πολύ αργός"</item>
     <item msgid="2361722960903353554">"Αργός"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Ποτέ όταν είναι συνδεδεμένο"</item>
     <item msgid="1986753720941888596">"Ποτέ"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Αυτόματο"</item>
+    <item msgid="6670588712989942178">"Μόνο 5 GHz"</item>
+    <item msgid="2715516524973207876">"Μόνο 2,4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Χρόνος χρήσης"</item>
     <item msgid="1908750532762193304">"Εκκίνηση καταμέτρησης"</item>
diff --git a/res/values-el/strings.xml b/res/values-el/strings.xml
index e9939fb..b29226a 100644
--- a/res/values-el/strings.xml
+++ b/res/values-el/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Επιλογή συσκευής Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Αίτημα άδειας Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Μια εφαρμογή στο τηλέφωνό σας ζητά δικαίωμα ενεργοποίησης του Bluetooth. Θέλετε να το επιτρέψετε;"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Μια εφαρμογή στο τηλέφωνό σας ζητά άδεια για καταστήσει τη συσκευή σας ορατή από άλλες συσκευές Bluetooth για <xliff:g id="TIMEOUT">%1$d</xliff:g> δευτερόλεπτα. Θέλετε να τη χορηγήσετε;"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Μια εφαρμογή στο τηλέφωνό σας ζητά άδεια για καταστήσει τη συσκευή σας ορατή από άλλες συσκευές Bluetooth για <xliff:g id="TIMEOUT">%1$d</xliff:g> δευτερόλεπτα. Θέλετε να τη χορηγήσετε;"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Μια εφαρμογή στο τηλέφωνό σας ζητά άδεια να ενεργοποιήσει το Bluetooth και να καταστήσει τη συσκευή σας ορατή από άλλες συσκευές για <xliff:g id="TIMEOUT">%1$d</xliff:g> δευτερόλεπτα. Θέλετε να τη χορηγήσετε;"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Μια εφαρμογή στο τηλέφωνό σας ζητά άδεια να ενεργοποιήσει το Bluetooth και να καταστήσει τη συσκευή σας ορατή από άλλες συσκευές για <xliff:g id="TIMEOUT">%1$d</xliff:g> δευτερόλεπτα. Θέλετε να τη χορηγήσετε;"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Ενεργοποίηση Bluetooth…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Ρυθμίσεις ημερομηνίας &amp; ώρας"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Πολιτική κατάστασης αδράνειας Wi-Fi"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Ορισμός εναλλαγής από δεδομένα Wi-Fi σε δεδομένα κινητού"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Παρουσιάστηκε ένα πρόβλημα κατά τη ρύθμιση της πολιτικής κατάστασης αδράνειας."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Ζώνη συχνοτήτων Wi-Fi"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Προσδιορίστε το εύρος συχνότητας της λειτουργίας"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Πρόβλημα κατά τη ρύθμιση της ζώνης συχνότητας."</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Διεύθυνση MAC"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Διεύθυνση IP"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"Ρυθμίσεις IP"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"Τοποθέτηση κάρτας SD"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Διαγρ. αποθ. χώρου USB"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"Διαγραφή κάρτας SD"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Διαγρ. δεδ. εσωτ. απ. χώρ. USB"</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Διαγραφή των δεδομένων στον εσωτερικό χώρο USB όπως μουσική και φωτογραφίες"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Διαγρ. δεδ. εσωτ. απ. χώρ. USB"</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"Μη διαθέσιμο"</string>
     <string name="read_only" msgid="6702420168629076340">" (Μόνο για ανάγνωση)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Επαναφορά εργοστασιακών δεδομένων"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Διαγραφή όλων των δεδομένων στο τηλέφωνο"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Διαγραφή όλων των δεδομένων στο τηλέφωνο"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Αυτή η ενέργεια θα διαγράψει όλα τα δεδομένα από τον "<b>"εσωτερικό χώρο αποθήκευσης"</b>" του υπολογιστή σας tablet, συμπεριλαμβανομένων των εξής:"\n\n<li>"Λογαριασμός Google"</li>\n<li>"Ρυθμίσεις δεδομένων συστήματος και εφαρμογών"</li>\n<li>"Εφαρμογές από λήψη"</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Αυτή η ενέργεια θα διαγράψει όλα τα δεδομένα από τον "<b>"εσωτερικό χώρο αποθήκευσης"</b>" του τηλεφώνου σας, συμπεριλαμβανομένων των εξής:"\n\n<li>"Λογαριασμός Google"</li>\n<li>"Ρυθμίσεις δεδομένων συστήματος και εφαρμογών"</li>\n<li>"Εφαρμογές από λήψη"</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Αυτήν τη στιγμή είστε συνδεδεμένοι στους παρακάτω λογαριασμούς:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Πρέπει να γίνει διαγραφή του "<b>"χώρου αποθήκευσης USB"</b>" για να γίνει, επίσης, εκκαθάριση της μουσικής, των εικόνων και άλλων δεδομένων."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Διαγρ. αποθ. χώρου USB"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Διαγραφή κάρτας SD"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Διαγράψτε όλα τα δεδομένα που υπάρχουν στον εσωτερικό αποθηκευτικό χώρο του τηλεφώνου σας, όπως αρχεία μουσικής και φωτογραφίες."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Διαγράψτε όλα τα δεδομένα που υπάρχουν στον εσωτερικό αποθηκευτικό χώρο του τηλεφώνου σας, όπως αρχεία μουσικής και φωτογραφίες."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Διαγράψτε όλα τα δεδομένα που υπάρχουν στον εσωτερικό αποθηκευτικό χώρο USB του τηλεφώνου σας, όπως αρχεία μουσικής και φωτογραφίες."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Διαγράψτε όλα τα δεδομένα που υπάρχουν στην κάρτα SD, όπως αρχεία μουσικής και φωτογραφίες."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Επαναφορά τηλεφώνου"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Επαναφορά τηλεφώνου"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"Να πραγματοποιηθεί διαγραφή όλων των προσωπικών στοιχείων και τυχόν εφαρμογών από λήψη; Αυτή η ενέργεια δεν είναι αναστρέψιμη!"</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Σχεδιάστε το μοτίβο ξεκλειδώματος"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Πρέπει να σχεδιάσετε το μοτίβο ξεκλειδώματος για επιβεβαίωση επαναφοράς τηλεφώνου."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"Δεν πραγματοποιήθηκε επαναφορά επειδή η υπηρεσία Εκκαθάρισης συστήματος δεν είναι διαθέσιμη."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Επιβεβαίωση επαναφοράς"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Διαγρ. αποθ. χώρου USB"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"Διαγραφή κάρτας SD"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Διαγρ. δεδομ. αποθ. χώρου USB"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Χρήση υποβοηθούμενου GPS"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"Χρήση διακομιστή για βοήθεια GPS (αποεπιλογή για να μειώσετε τη χρήση του δικτύου)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"Χρήση διακομιστή για βοήθεια του GPS (αποεπιλογή για βελτίωση της απόδοσης του GPS)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"Χρήση της τοποθεσίας μου"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Χρήση τοποθεσίας για Αναζήτηση Google"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Χρήση της τοποθεσίας για την Αναζήτηση Google και για άλλες υπηρεσίες Google"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"Τοποθεσία που χρησιμοποιήθηκε για τη βελτίωση των αποτελ. αναζήτησης Google και άλλων υπηρεσ. Google"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"Σχετικά με το τηλέφωνο"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"Σχετικά με το τηλέφωνο"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Προβ.νομ.πληροφ., κατάστ.τηλεφ., έκδ.λογισμ."</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Φόρτωση..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Πληροφορίες ασφάλειας"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Πληροφορίες ασφάλειας"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Το τηλέφωνό σας δεν είναι συνδεδεμένο σε υπηρεσία δεδομένων. Για να προβάλετε αυτές τις πληροφορίες τώρα, μεταβείτε στο %s από οποιονδήποτε υπολογιστή με σύνδεση στο Διαδίκτυο."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Φόρτωση..."</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Επιλέξτε τον κωδικό πρόσβασης"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Επιλέξτε τον αριθμό PIN"</string>
diff --git a/res/values-en-rGB/arrays.xml b/res/values-en-rGB/arrays.xml
index c3fe001..6ce5d06 100644
--- a/res/values-en-rGB/arrays.xml
+++ b/res/values-en-rGB/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Some window animations are shown"</item>
     <item msgid="488968798204105119">"All window animations are shown"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 seconds"</item>
-    <item msgid="8881760709354815449">"30 seconds"</item>
-    <item msgid="7589406073232279088">"1 minute"</item>
-    <item msgid="7001195990902244174">"2 minutes"</item>
-    <item msgid="5721688686241190620">"10 minutes"</item>
-    <item msgid="7156442995039264948">"30 minutes"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Very slow"</item>
     <item msgid="2361722960903353554">"Slow"</item>
diff --git a/res/values-en-rGB/strings.xml b/res/values-en-rGB/strings.xml
index 6636199..478e69b 100644
--- a/res/values-en-rGB/strings.xml
+++ b/res/values-en-rGB/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Bluetooth device picker"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Bluetooth permission request"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"An application on your phone is requesting permission to turn on Bluetooth. Do you want to do this?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"An application on your phone is requesting permission to make your phone discoverable by other Bluetooth devices for <xliff:g id="TIMEOUT">%1$d</xliff:g> seconds. Do you want to do this?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"An application on your phone is requesting permission to make your phone discoverable by other Bluetooth devices for <xliff:g id="TIMEOUT">%1$d</xliff:g> seconds. Do you want to do this?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"An application on your phone is requesting permission to turn on Bluetooth and make your phone discoverable by other devices for <xliff:g id="TIMEOUT">%1$d</xliff:g> seconds. Do you want to do this?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"An application on your phone is requesting permission to turn on Bluetooth and make your phone discoverable by other devices for <xliff:g id="TIMEOUT">%1$d</xliff:g> seconds. Do you want to do this?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Turning on Bluetooth…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Date &amp; time settings"</string>
@@ -863,7 +865,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Loading…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Safety information"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Safety information"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Your phone is not connected to a data service. To view this information now, go to %s from any computer connected to the Internet."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Loading…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Choose your password"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Choose your PIN"</string>
@@ -1012,8 +1015,10 @@
     <string name="service_started_by_app" msgid="6575184738671598131">"Started by application."</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- outdated translation 4939976652114824214 -->     <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> available"</string>
-    <!-- outdated translation 2474726487867913314 -->     <string name="service_foreground_processes" msgid="7583975676795574276">"<xliff:g id="MEMORY">%1$s</xliff:g> in use"</string>
+    <!-- no translation found for service_background_processes (6844156253576174488) -->
+    <skip />
+    <!-- no translation found for service_foreground_processes (7583975676795574276) -->
+    <skip />
     <!-- no translation found for memory (6609961111091483458) -->
     <skip />
     <!-- no translation found for service_process_name (4098932168654826656) -->
diff --git a/res/values-es-rUS/arrays.xml b/res/values-es-rUS/arrays.xml
index 78db2d1..051ab98 100644
--- a/res/values-es-rUS/arrays.xml
+++ b/res/values-es-rUS/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"Se muestran algunas animaciones de ventana"</item>
     <item msgid="488968798204105119">"Se muestran todas las animaciones de ventana"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 segundos"</item>
-    <item msgid="8881760709354815449">"30 segundos"</item>
-    <item msgid="7589406073232279088">"1 minuto"</item>
-    <item msgid="7001195990902244174">"2 minutos"</item>
-    <item msgid="5721688686241190620">"10 minutos"</item>
-    <item msgid="7156442995039264948">"30 minutos"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"inmediatamente"</item>
-    <item msgid="6736512735606834431">"5 segundos"</item>
-    <item msgid="8044619388267891375">"15 segundos"</item>
-    <item msgid="1822002388249545488">"30 segundos"</item>
-    <item msgid="8538071621211916519">"1 minuto"</item>
-    <item msgid="5663439580228932882">"2 minutos"</item>
-    <item msgid="7505084444184116101">"10 minutos"</item>
-    <item msgid="4621683909972069205">"30 minutos"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Muy lento"</item>
     <item msgid="2361722960903353554">"Lento"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Nunca cuando está conectado"</item>
     <item msgid="1986753720941888596">"Nunca"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Automáticamente"</item>
+    <item msgid="6670588712989942178">"Sólo 5 GHz"</item>
+    <item msgid="2715516524973207876">"Sólo 2.4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Hora de uso"</item>
     <item msgid="1908750532762193304">"Lanzar recuento"</item>
diff --git a/res/values-es-rUS/strings.xml b/res/values-es-rUS/strings.xml
index f8c9a96..06a9bf8 100644
--- a/res/values-es-rUS/strings.xml
+++ b/res/values-es-rUS/strings.xml
@@ -115,9 +115,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Selector de dispositivo Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Solicitud de permiso de Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Una aplicación de tu teléfono solicita permiso para activar Bluetooth. ¿Deseas activarlo?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Una aplicación de tu teléfono solicita permiso para hacer que tu teléfono pueda ser detectable por otros dispositivos de Bluetooth durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. ¿Deseas activarlo?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Una aplicación de tu teléfono solicita permiso para hacer que tu teléfono pueda ser detectable por otros dispositivos de Bluetooth durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. ¿Deseas activarlo?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Una aplicación de tu teléfono solicita permiso para activar Bluetooth y hacer que tu teléfono pueda ser detectable por otros dispositivos durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. ¿Deseas activarlo?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Una aplicación de tu teléfono solicita permiso para activar Bluetooth y hacer que tu teléfono pueda ser detectable por otros dispositivos durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. ¿Deseas activarlo?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Activando Bluetooth…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Configuración de fecha y hora"</string>
@@ -458,12 +460,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Política de estado de inactividad de Wi-Fi"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Especificar cuándo se debe cambiar de Wi-Fi a datos de celular"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Se ha producido un problema al establecer la política de estado de inactividad."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Banda de frecuencia Wi-Fi"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Especificar el rango de frecuencia de la operación"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Problema al configurar la banda de frecuencias."</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Dirección de MAC"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Dirección IP"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"Configuración de IP"</string>
@@ -636,7 +635,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"Montar la tarjeta SD"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Borrar almacenamiento USB"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"Borrar la tarjeta SD"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Borra todos los datos del almacenamiento USB interno del teléfono, como la música y las fotos"</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Borra todos los datos del almacenamiento USB interno, como la música y las fotos"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Borra todos los datos del almacenamiento USB interno del teléfono, como la música y las fotos"</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"No disponible"</string>
     <string name="read_only" msgid="6702420168629076340">" (Sólo lectura)"</string>
@@ -690,24 +689,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Restabl. datos de fábrica"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Borra todos los datos del teléfono"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Borra todos los datos del teléfono"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Esto borrará todos los datos del "<b>"almacenamiento interno"</b>" de tu tableta, incluidos "\n\n<li>"Tu cuenta de Google"</li>\n<li>"Datos del sistema y aplicaciones y configuración"</li>\n<li>"Aplicaciones descargadas"</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Esto borrará todos los datos del "<b>"almacenamiento interno"</b>" del teléfono, incluidos "\n\n<li>"Tu cuenta de Google"</li>\n<li>"Datos del sistema y aplicaciones y configuración"</li>\n<li>"Aplicaciones descargadas"</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Actualmente has accedido a las siguientes cuentas:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Para borrar la música, las imágenes y otros datos del usuario, debes borrar el "<b>"almacenamiento USB"</b>"."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Borrar almacenamiento USB"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Borrar la tarjeta SD"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Borrar todos los datos del almacenamiento USB del teléfono, como la música o las fotos."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Borrar todos los datos del almacenamiento USB del teléfono, como la música o las fotos."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Borrar todos los datos del almacenamiento USB, como la música o las fotos."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Borra todos los datos de la tarjeta SD, como la música o las fotos."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Restablecer el teléfono"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Restablecer el teléfono"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"¿Deseas borrar toda tu información personal y cualquier aplicación descargada?"</string>
@@ -715,8 +706,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Extrae tu patrón de desbloqueo"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Debes extraer tu patrón de desbloqueo para confirmar el restablecimiento de un teléfono."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"No se ha realizado ningún restablecimiento debido a que el servicio \"Borrar sistema\" no se encuentra disponible."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Confirmar restablecimiento"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Borrar almacenamiento USB"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"Borrar la tarjeta SD"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Borra todos los datos del almacenamiento USB"</string>
@@ -798,7 +788,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Cargando…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Información de seguridad"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Información de seguridad"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Tu teléfono no está conectado al servicio de datos. Para ver esta información ahora, visita %s desde cualquier computadora conectada a Internet."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Cargando…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Elegir la contraseña"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Elige tu PIN"</string>
diff --git a/res/values-es/arrays.xml b/res/values-es/arrays.xml
index 5ddf014..5a8c969 100644
--- a/res/values-es/arrays.xml
+++ b/res/values-es/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"Aparecen algunas animaciones de ventana."</item>
     <item msgid="488968798204105119">"Aparecen todas las animaciones de ventana."</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 segundos"</item>
-    <item msgid="8881760709354815449">"30 segundos"</item>
-    <item msgid="7589406073232279088">"1 minuto"</item>
-    <item msgid="7001195990902244174">"2 minutos"</item>
-    <item msgid="5721688686241190620">"10 minutos"</item>
-    <item msgid="7156442995039264948">"30 minutos"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"inmediatamente"</item>
-    <item msgid="6736512735606834431">"5 segundos"</item>
-    <item msgid="8044619388267891375">"15 segundos"</item>
-    <item msgid="1822002388249545488">"30 segundos"</item>
-    <item msgid="8538071621211916519">"1 minuto"</item>
-    <item msgid="5663439580228932882">"2 minutos"</item>
-    <item msgid="7505084444184116101">"10 minutos"</item>
-    <item msgid="4621683909972069205">"30 minutos"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Muy lenta"</item>
     <item msgid="2361722960903353554">"Lenta"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Nunca si se está cargando la batería"</item>
     <item msgid="1986753720941888596">"Nunca"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Automático"</item>
+    <item msgid="6670588712989942178">"Solo 5 GHz"</item>
+    <item msgid="2715516524973207876">"Solo 2,4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Tiempo de uso"</item>
     <item msgid="1908750532762193304">"Número de inicios"</item>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index 7da6819..f77f1e6 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Selector del dispositivo Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Solicitud de permiso de Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Una aplicación del teléfono está solicitando permiso para activar la función Bluetooth. ¿Quieres realizar esta acción?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Una aplicación del teléfono está solicitando permiso para hacer visible el teléfono para otros dispositivos Bluetooth durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. ¿Quieres realizar esta acción?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Una aplicación del teléfono está solicitando permiso para hacer visible el teléfono para otros dispositivos Bluetooth durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. ¿Quieres realizar esta acción?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Una aplicación del teléfono está solicitando permiso para activar la función Bluetooth y hacer visible el teléfono para otros dispositivos durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. ¿Quieres realizar esta acción?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Una aplicación del teléfono está solicitando permiso para activar la función Bluetooth y hacer visible el teléfono para otros dispositivos durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. ¿Quieres realizar esta acción?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Activando Bluetooth..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"Ajustes de fecha y hora"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Política de suspensión de Wi-Fi"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Especificar cuándo cambiar de Wi-Fi a datos móviles"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Se ha producido un problema al intentar establecer la política de suspensión."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Banda de frecuencia WiFi"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Especificar intervalo frecuencia de funcionamiento"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Error al establecer la banda de frecuencia"</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Dirección MAC"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Dirección IP"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"Ajustes de IP"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"Activar tarjeta SD"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Borrar almacenamiento USB"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"Borrar tarjeta SD"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Borr dat USB intern (mús, fot)"</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Permite borrar los datos del almacenamiento USB interno, como música y fotos."</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Borr dat USB intern (mús, fot)"</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"No disponible"</string>
     <string name="read_only" msgid="6702420168629076340">" (Sólo lectura)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Restablecer datos de fábrica"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Borrar todos los datos del teléfono"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Borrar todos los datos del teléfono"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Se borrará toda la información del "<b>"almacenamiento interno"</b>" de la tableta, incluidos:"\n\n<li>"los datos de tu cuenta de Google,"</li>\n<li>"los datos de configuración e información de aplicaciones y del sistema,"</li>\n<li>"los datos de aplicaciones descargadas"</li>"."</string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Se borrará toda la información del "<b>"almacenamiento interno"</b>" del teléfono, incluidos:"\n\n<li>"los datos de tu cuenta de Google,"</li>\n<li>"los datos de configuración e información de aplicaciones y del sistema,"</li>\n<li>"los datos de aplicaciones descargadas"</li>"."</string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Has accedido a las cuentas que se indican a continuación:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Si también quieres borrar la música, las imágenes y otros datos de usuario, debes borrar el "<b>"almacenamiento USB"</b>"."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Borrar almacenamiento USB"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Borrar tarjeta SD"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Borr dat USB intern (mús, fot)"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Borr dat USB intern (mús, fot)"</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Borra todos los datos del almacenamiento USB interno, como la música o las fotos."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Borra todos los datos de la tarjeta SD, como la música o las fotos."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Reiniciar teléfono"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Reiniciar teléfono"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"¿Quieres borrar toda tu información personal y las aplicaciones que has descargado? Esta acción no se puede deshacer."</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Crea tu patrón de desbloqueo."</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Debes crear un patrón de desbloqueo para confirmar el reinicio del teléfono."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"No se ha reiniciado el sistema porque el servicio Borrado del sistema no está disponible."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Confirmar restablecimiento"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Borrar almacenamiento USB"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"Borrar tarjeta SD"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Borra los datos de USB"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Utilizar GPS asistido"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"Utilizar el servidor para asistir al GPS (desactivar para reducir el uso de la red)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"Utilizar el servidor para asistir al GPS (desactivar para mejorar el rendimiento del GPS)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"Utilizar Mi ubicación"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Usar ubicación para la búsqueda de Google"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Usar la ubicación para la búsqueda de Google y otros servicios de Google"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"La ubicación se usa para mejorar los resultados de búsqueda de Google y otros servicios de Google."</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"Acerca del teléfono"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"Acerca del teléfono"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Ver información legal, estado del teléfono, versión del software"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Cargando..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Información de seguridad"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Información de seguridad"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"El teléfono no está conectado a un servicio de datos. Para ver esta información, accede a %s desde cualquier equipo conectado a Internet."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Cargando..."</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Selecciona tu contraseña"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Selecciona tu PIN"</string>
diff --git a/res/values-fa/arrays.xml b/res/values-fa/arrays.xml
index f45193b..bf38f6e 100644
--- a/res/values-fa/arrays.xml
+++ b/res/values-fa/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"برخی از انیمیشن های پنجره نمایش داده می شوند"</item>
     <item msgid="488968798204105119">"تمام انیمیشن های پنجره نمایش داده می شوند"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 ثانیه"</item>
-    <item msgid="8881760709354815449">"30 ثانیه"</item>
-    <item msgid="7589406073232279088">"1 دقیقه قبل"</item>
-    <item msgid="7001195990902244174">"2 دقیقه"</item>
-    <item msgid="5721688686241190620">"10 دقیقه"</item>
-    <item msgid="7156442995039264948">"30 دقیقه"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"بسیار آهسته"</item>
     <item msgid="2361722960903353554">"آهسته"</item>
diff --git a/res/values-fa/strings.xml b/res/values-fa/strings.xml
index 42e0d2a..1a3000d 100644
--- a/res/values-fa/strings.xml
+++ b/res/values-fa/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"انتخاب کننده دستگاه بلوتوث"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"درخواست مجوز بلوتوث"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"برنامه ای در گوشی شما درخواست کرده است که بلوتوث روشن شود. می خواهید این کار را انجام دهید؟"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"برنامه ای در گوشی شما درخواست کرده است که گوشی شما برای <xliff:g id="TIMEOUT">%1$d</xliff:g> ثانیه برای دیگر دستگاه های بلوتوث قابل شناسایی باشد. می خواهید این کار را انجام دهید؟"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"برنامه ای در گوشی شما درخواست کرده است که گوشی شما برای <xliff:g id="TIMEOUT">%1$d</xliff:g> ثانیه برای دیگر دستگاه های بلوتوث قابل شناسایی باشد. می خواهید این کار را انجام دهید؟"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"برنامه ای در گوشی شما درخواست مجوز برای روشن کردن بلوتوث کرده و اینکه دستگاه شما برای دیگر دستگاه ها به مدت <xliff:g id="TIMEOUT">%1$d</xliff:g> ثانیه قابل شناسایی باشد. می خواهید این کار را انجام دهید؟"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"برنامه ای در گوشی شما درخواست مجوز برای روشن کردن بلوتوث کرده و اینکه دستگاه شما برای دیگر دستگاه ها به مدت <xliff:g id="TIMEOUT">%1$d</xliff:g> ثانیه قابل شناسایی باشد. می خواهید این کار را انجام دهید؟"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"خاموش کردن بلوتوث..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"تنظیمات تاریخ و ساعت"</string>
@@ -863,7 +865,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"در حال بارگیری…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"اطلاعات ایمنی"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"اطلاعات ایمنی"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"گوشی شما به سرویس داده متصل نیست. برای مشاهده این اطلاعات، از هر رایانه متصل به اینترنت به %s بروید."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"در حال بارگیری…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"رمز ورود خود را انتخاب کنید"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"پین خود را انتخاب کنید"</string>
@@ -1012,12 +1015,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"شروع شده توسط برنامه: برای توقف لمس کنید"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-fi/arrays.xml b/res/values-fi/arrays.xml
index d1e012b..8674f34 100644
--- a/res/values-fi/arrays.xml
+++ b/res/values-fi/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Joitakin ikkuna-animaatioita näytetään"</item>
     <item msgid="488968798204105119">"Kaikki ikkuna-animaatiot näytetään"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 sekuntia"</item>
-    <item msgid="8881760709354815449">"30 sekuntia"</item>
-    <item msgid="7589406073232279088">"1 minuutti"</item>
-    <item msgid="7001195990902244174">"2 minuuttia"</item>
-    <item msgid="5721688686241190620">"10 minuuttia"</item>
-    <item msgid="7156442995039264948">"30 minuuttia"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Hyvin hidas"</item>
     <item msgid="2361722960903353554">"Hidas"</item>
diff --git a/res/values-fi/strings.xml b/res/values-fi/strings.xml
index 898bbf8..b455ccc 100644
--- a/res/values-fi/strings.xml
+++ b/res/values-fi/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Bluetooth-laitevalitsin"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Bluetooth-yhteyspyyntö"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Puhelimesi sovellus pyytää lupaa ottaa Bluetooth-yhteyden käyttöön. Haluatko myöntää luvan?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Puhelimesi sovellus pyytää lupaa asettaa puhelimesi muiden Bluetooth-laitteiden tunnistettavaksi <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunnin ajaksi. Haluatko myöntää luvan?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Puhelimesi sovellus pyytää lupaa asettaa puhelimesi muiden Bluetooth-laitteiden tunnistettavaksi <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunnin ajaksi. Haluatko myöntää luvan?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Puhelimesi sovellus pyytää lupaa ottaa Bluetooth-yhteyden käyttöön ja asettaa puhelimesi muiden Bluetooth-laitteiden tunnistettavaksi <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunnin ajaksi. Haluatko myöntää luvan?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Puhelimesi sovellus pyytää lupaa ottaa Bluetooth-yhteyden käyttöön ja asettaa puhelimesi muiden Bluetooth-laitteiden tunnistettavaksi <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunnin ajaksi. Haluatko myöntää luvan?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Otetaan Bluetooth-yhteys käyttöön…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Päivämäärä- ja aika-asetukset"</string>
@@ -856,7 +858,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Ladataan…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Suojaustiedot"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Suojaustiedot"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Puhelimellasi ei ole yhteyttä verkkoon. Voit katsella näitä tietoja siirtymällä osoitteeseen %s internetyhteyttä käyttävällä tietokoneella."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Ladataan…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Valitse salasana"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Valitse PIN-koodi"</string>
@@ -1005,12 +1008,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Sovelluksen käynnistämä: lopeta koskettamalla"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-fr/arrays.xml b/res/values-fr/arrays.xml
index f482af7..6e5e867 100644
--- a/res/values-fr/arrays.xml
+++ b/res/values-fr/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"Certaines animations sont affichées."</item>
     <item msgid="488968798204105119">"Toutes les animations sont affichées"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 secondes"</item>
-    <item msgid="8881760709354815449">"30 secondes"</item>
-    <item msgid="7589406073232279088">"1 minute"</item>
-    <item msgid="7001195990902244174">"2 minutes"</item>
-    <item msgid="5721688686241190620">"10 minutes"</item>
-    <item msgid="7156442995039264948">"30 minutes"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"immédiatement"</item>
-    <item msgid="6736512735606834431">"5 secondes"</item>
-    <item msgid="8044619388267891375">"15 secondes"</item>
-    <item msgid="1822002388249545488">"30 secondes"</item>
-    <item msgid="8538071621211916519">"1 minute"</item>
-    <item msgid="5663439580228932882">"2 minutes"</item>
-    <item msgid="7505084444184116101">"10 minutes"</item>
-    <item msgid="4621683909972069205">"30 minutes"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Très lente"</item>
     <item msgid="2361722960903353554">"Lente"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Jamais si branché"</item>
     <item msgid="1986753720941888596">"Jamais"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Automatique"</item>
+    <item msgid="6670588712989942178">"5 GHz uniquement"</item>
+    <item msgid="2715516524973207876">"2,4 GHz uniquement"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Temps d\'utilisation"</item>
     <item msgid="1908750532762193304">"Nombre de lancements"</item>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index e9902f3..cce7f66 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Sélecteur de périphérique Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Demande d\'autorisation Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Une application sur votre téléphone demande l\'autorisation d\'activer Bluetooth. Voulez-vous l\'activer ?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Une application sur votre téléphone demande l\'autorisation d\'activer la fonction de détection de votre téléphone par d\'autres appareils Bluetooth pendant <xliff:g id="TIMEOUT">%1$d</xliff:g> secondes. Voulez-vous l\'activer ?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Une application sur votre téléphone demande l\'autorisation d\'activer la fonction de détection de votre téléphone par d\'autres appareils Bluetooth pendant <xliff:g id="TIMEOUT">%1$d</xliff:g> secondes. Voulez-vous l\'activer ?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Une application sur votre téléphone demande l\'autorisation d\'activer Bluetooth et de permettre à d\'autres appareils de détecter votre téléphone pendant <xliff:g id="TIMEOUT">%1$d</xliff:g> secondes. Voulez-vous l\'activer ?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Une application sur votre téléphone demande l\'autorisation d\'activer Bluetooth et de permettre à d\'autres appareils de détecter votre téléphone pendant <xliff:g id="TIMEOUT">%1$d</xliff:g> secondes. Voulez-vous l\'activer ?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Activation du Bluetooth…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Paramètres d\'heure et de date"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Politique de veille Wi-Fi"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Indiquer quand basculer du Wi-Fi sur le réseau de données mobile"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Un problème est survenu lors du paramétrage de la politique de veille."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Plage de fréquences Wi-Fi"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Définir la plage de fréquences"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Erreur de paramétrage de la plage de fréquences"</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Adresse MAC"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Adresse IP"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"Paramètres IP"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"Monter la carte SD"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Effacer la mémoire USB"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"Effacer la carte SD"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Effacer les données de la mémoire USB interne (ex. : musique, photos)"</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Effacer les données de la mémoire de stockage USB interne (ex. : musique, photos)"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Effacer les données de la mémoire USB interne (ex. : musique, photos)"</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"Non disponible"</string>
     <string name="read_only" msgid="6702420168629076340">" (Lecture seule)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Restaurer valeurs d\'usine"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Effacer toutes les données du téléphone"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Effacer toutes les données du téléphone"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Cette action effacera toutes les données de la "<b>"mémoire de stockage interne"</b>" de votre tablette, y compris :"\n\n<li>"Votre compte Google"</li>\n<li>"Les données et les paramètres des applications et du système"</li>\n<li>"Les applications téléchargées"</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Cette action effacera toutes les données de la "<b>"mémoire de stockage interne"</b>" de votre mobile, y compris :"\n\n<li>"Votre compte Google"</li>\n<li>"Les données et les paramètres des applications et du système"</li>\n<li>"Les applications téléchargées"</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Vous êtes actuellement connecté aux comptes suivants :"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Pour supprimer également la musique, les photos et les autres données utilisateur, vous devez effacer la "<b>"mémoire de stockage USB"</b>"."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Effacer la mémoire USB"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Effacer la carte SD"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Effacer les données de la mémoire USB interne (ex. : musique, photos)."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Effacer les données de la mémoire USB interne (ex. : musique, photos)."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Effacer toutes les données de la mémoire de stockage USB interne (ex. : musique, photos)"</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Effacer toutes les données de la carte SD (ex. : musique, photos)"</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Réinitialiser le téléphone"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Réinitialiser le téléphone"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"Souhaitez-vous vraiment supprimer toutes vos informations personnelles et toutes les applications téléchargées ? Cette action ne peut pas être annulée."</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Saisissez votre schéma de déverrouillage"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Vous devez dessiner votre schéma de déverrouillage pour confirmer la réinitialisation du téléphone."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"Les données n\'ont pas été réinitialisées car le service de nettoyage du système n\'est pas disponible."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Confirmer la réinitialisation"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Effacer la mémoire USB"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"Effacer la carte SD"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Efface les données de la mémoire USB"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Utiliser le GPS assisté"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"Utiliser le serveur pour assister le GPS (désactiver pour réduire l\'utilisation du réseau)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"Utiliser le serveur pour assister le GPS (désactiver pour améliorer les performances du GPS)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"Utiliser ma position"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Utiliser Ma position pour la recherche Google"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Utiliser Ma position pour la recherche et les autres services Google"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"Les résultats de recherche et les autres services Google sont améliorés via Ma position."</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"À propos du téléphone"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"À propos du téléphone"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Informations légales, état du téléphone et version du logiciel"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Chargement..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informations de sécurité"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informations de sécurité"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Votre téléphone n\'est connecté à aucun service de données. Pour consulter ces informations maintenant, accédez à %s depuis un ordinateur connecté à Internet."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Chargement…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Choisir votre mot de passe"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Choisir votre code PIN"</string>
diff --git a/res/values-he/arrays.xml b/res/values-he/arrays.xml
index 2006a80..afd66aa 100644
--- a/res/values-he/arrays.xml
+++ b/res/values-he/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"חלק מהנפשות החלון מוצגות"</item>
     <item msgid="488968798204105119">"כל הנפשות החלון מוצגות"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 שניות"</item>
-    <item msgid="8881760709354815449">"שניות"</item>
-    <item msgid="7589406073232279088">"דקה אחת"</item>
-    <item msgid="7001195990902244174">"2 דקות"</item>
-    <item msgid="5721688686241190620">"10 דקות"</item>
-    <item msgid="7156442995039264948">"30 דקות"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"איטי מאוד"</item>
     <item msgid="2361722960903353554">"לאט"</item>
diff --git a/res/values-he/strings.xml b/res/values-he/strings.xml
index 3a555837..5392898 100644
--- a/res/values-he/strings.xml
+++ b/res/values-he/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"בוחר התקני Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"בקשת הרשאה של Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"יישום בטלפון מבקש הרשאה להפעיל Bluetooth. האם ברצונך להפעיל?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"יישום בטלפון מבקש הרשאה להפוך את הטלפון לגלוי להתקני Bluetooth אחרים למשך <xliff:g id="TIMEOUT">%1$d</xliff:g> שניות. האם ברצונך לעשות זאת?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"יישום בטלפון מבקש הרשאה להפוך את הטלפון לגלוי להתקני Bluetooth אחרים למשך <xliff:g id="TIMEOUT">%1$d</xliff:g> שניות. האם ברצונך לעשות זאת?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"יישום בטלפון מבקש הרשאה להפעיל Bluetooth ולהפוך את הטלפון לגלוי להתקנים אחרים למשך <xliff:g id="TIMEOUT">%1$d</xliff:g> שניות. האם ברצונך לבצע פעולות אלה?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"יישום בטלפון מבקש הרשאה להפעיל Bluetooth ולהפוך את הטלפון לגלוי להתקנים אחרים למשך <xliff:g id="TIMEOUT">%1$d</xliff:g> שניות. האם ברצונך לבצע פעולות אלה?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"מפעיל Bluetooth…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"הגדרות תאריך ושעה"</string>
@@ -856,7 +858,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"טוען…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"מידע על בטיחות"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"מידע על בטיחות"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"הטלפון שלך לא מחובר לשירות נתונים. כדי להציג מידע זה כעת, עבור אל %s מכל מחשב המחובר לאינטרנט."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"טוען…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"בחר סיסמה"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"בחר את ה-PIN"</string>
@@ -1005,12 +1008,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"הופעל על ידי יישום: גע כדי לעצור"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-hr/arrays.xml b/res/values-hr/arrays.xml
index 1dc7656..66ddf08 100644
--- a/res/values-hr/arrays.xml
+++ b/res/values-hr/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Prikazan je dio animacija prozora"</item>
     <item msgid="488968798204105119">"Prikazane su sve animacija prozora"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 sekundi"</item>
-    <item msgid="8881760709354815449">"30 sekundi"</item>
-    <item msgid="7589406073232279088">"1 minuta"</item>
-    <item msgid="7001195990902244174">"2 minute"</item>
-    <item msgid="5721688686241190620">"10 minuta"</item>
-    <item msgid="7156442995039264948">"30 minuta"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Jako sporo"</item>
     <item msgid="2361722960903353554">"Sporo"</item>
diff --git a/res/values-hr/strings.xml b/res/values-hr/strings.xml
index 0e5aaee..7dc63c5 100644
--- a/res/values-hr/strings.xml
+++ b/res/values-hr/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Alat za odabir Bluetooth uređaja"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Zatraženo je Bluetooth dopuštenje"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Aplikacija na vašem telefonu traži dopuštenje za uključivanje značajke Bluetooth. Želite li to dopustiti?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Aplikacija na vašem telefonu traži dopuštenje da vaš telefon učini vidljivim drugim Bluetooth uređajima na <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Želite li to dopustiti?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Aplikacija na vašem telefonu traži dopuštenje da vaš telefon učini vidljivim drugim Bluetooth uređajima na <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Želite li to dopustiti?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Aplikacija na vašem telefonu traži dopuštenje za uključivanje značajke Bluetooth i da vaš telefon učini vidljivim drugim Bluetooth uređajima na <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Želite li to dopustiti?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Aplikacija na vašem telefonu traži dopuštenje za uključivanje značajke Bluetooth i da vaš telefon učini vidljivim drugim Bluetooth uređajima na <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Želite li to dopustiti?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Uključivanje Bluetootha…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Postavke datuma i vremena"</string>
@@ -863,7 +865,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Učitavanje…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Sigurnosne informacije"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Sigurnosne informacije"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Vaš telefon nije priključen na podatkovnu uslugu. Da biste sad pogledali te informacije, idite na stavku %s s bilo kojeg internetski povezanog računala."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Učitavanje…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Odaberite svoju zaporku"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Odaberite PIN"</string>
@@ -1012,12 +1015,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Pokrenula aplikacija: dotaknite za zaustavljanje"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-hu/arrays.xml b/res/values-hu/arrays.xml
index e5526be..62f5933 100644
--- a/res/values-hu/arrays.xml
+++ b/res/values-hu/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Egyes ablakanimációk megjelenítése"</item>
     <item msgid="488968798204105119">"Minden ablakanimáció megjelenítése"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 másodperc"</item>
-    <item msgid="8881760709354815449">"30 másodperc"</item>
-    <item msgid="7589406073232279088">"1 perc"</item>
-    <item msgid="7001195990902244174">"2 perc"</item>
-    <item msgid="5721688686241190620">"10 perc"</item>
-    <item msgid="7156442995039264948">"30 perc"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Nagyon lassú"</item>
     <item msgid="2361722960903353554">"Lassú"</item>
diff --git a/res/values-hu/strings.xml b/res/values-hu/strings.xml
index 771d9d5..d4301aa 100644
--- a/res/values-hu/strings.xml
+++ b/res/values-hu/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Bluetooth-eszközválasztó"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Bluetooth engedélykérés"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Az egyik alkalmazás engedélyt kér a Bluetooth bekapcsolására. Engedélyezi?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Az egyik alkalmazás engedélyt kér arra, hogy <xliff:g id="TIMEOUT">%1$d</xliff:g> másodpercre felderíthetővé tegye telefonját más Bluetooth eszközök számára. Engedélyezi ezt?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Az egyik alkalmazás engedélyt kér arra, hogy <xliff:g id="TIMEOUT">%1$d</xliff:g> másodpercre felderíthetővé tegye telefonját más Bluetooth eszközök számára. Engedélyezi ezt?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Az egyik alkalmazás engedélyt kér arra, hogy <xliff:g id="TIMEOUT">%1$d</xliff:g> másodpercre felderíthetővé tegye telefonját más eszközök számára. Engedélyezi ezt?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Az egyik alkalmazás engedélyt kér arra, hogy <xliff:g id="TIMEOUT">%1$d</xliff:g> másodpercre felderíthetővé tegye telefonját más eszközök számára. Engedélyezi ezt?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"A Bluetooth bekapcsolása..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"Dátum és idő beállításai"</string>
@@ -856,7 +858,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Betöltés…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Biztonsági információk"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Biztonsági információk"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"A telefon nem kapcsolódik adatszolgáltatáshoz. Az információ azonnali megtekintéséhez keresse fel a(z) %s webhelyet egy olyan számítógépről, amelyen van internet-hozzáférés."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Betöltés…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Adjon meg egy jelszót"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Adja meg PIN-kódját"</string>
@@ -1005,12 +1008,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Alkalmazás által elindítva: érintse meg a leállításához"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-id/arrays.xml b/res/values-id/arrays.xml
index 99800e9..68e9d67 100644
--- a/res/values-id/arrays.xml
+++ b/res/values-id/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Sebagian animasi jendela ditampilkan"</item>
     <item msgid="488968798204105119">"Semua animasi jendela ditampilkan"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 detik"</item>
-    <item msgid="8881760709354815449">"30 detik"</item>
-    <item msgid="7589406073232279088">"1 menit"</item>
-    <item msgid="7001195990902244174">"2 menit"</item>
-    <item msgid="5721688686241190620">"10 menit"</item>
-    <item msgid="7156442995039264948">"30 menit"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Sangat lambat"</item>
     <item msgid="2361722960903353554">"Lambat"</item>
diff --git a/res/values-id/strings.xml b/res/values-id/strings.xml
index 5504367..8b3ead1 100644
--- a/res/values-id/strings.xml
+++ b/res/values-id/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Pemilih perangkat bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Permintaan izin bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Aplikasi pada ponsel Anda meminta izin untuk menghidupkan Bluetooth. Apakah Anda ingin melakukannya?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Aplikasi pada ponsel Anda meminta izin untuk membuat ponsel Anda dapat ditemukan oleh perangkat Bluetooth lain selama <xliff:g id="TIMEOUT">%1$d</xliff:g> detik. Apakah Anda ingin melakukannya?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Aplikasi pada ponsel Anda meminta izin untuk membuat ponsel Anda dapat ditemukan oleh perangkat Bluetooth lain selama <xliff:g id="TIMEOUT">%1$d</xliff:g> detik. Apakah Anda ingin melakukannya?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Aplikasi pada ponsel Anda meminta izin untuk mengaktifkan Bluetooth dan untuk membuat ponsel Anda dapat ditemukan oleh perangkat lain selama <xliff:g id="TIMEOUT">%1$d</xliff:g> detik. Apakah Anda ingin melakukannya?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Aplikasi pada ponsel Anda meminta izin untuk mengaktifkan Bluetooth dan untuk membuat ponsel Anda dapat ditemukan oleh perangkat lain selama <xliff:g id="TIMEOUT">%1$d</xliff:g> detik. Apakah Anda ingin melakukannya?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Menghidupkan Bluetooth..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"Setelan tanggal &amp; waktu"</string>
@@ -865,7 +867,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Memuat…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informasi keselamatan"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informasi keselamatan"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Ponsel Anda tidak tersambung ke layanan data. Untuk melihat informasi ini sekarang, buka %s dari komputer mana pun yang tersambung ke internet."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Memuat…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Pilih sandi Anda"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Pilih PIN Anda"</string>
@@ -1014,12 +1017,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Dimulai oleh aplikasi: sentuh untuk berhenti"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-it/arrays.xml b/res/values-it/arrays.xml
index 5ecc450..7f699ce 100644
--- a/res/values-it/arrays.xml
+++ b/res/values-it/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"Vengono visualizzate alcune animazioni delle finestre"</item>
     <item msgid="488968798204105119">"Vengono visualizzate tutte le animazioni delle finestre"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 secondi"</item>
-    <item msgid="8881760709354815449">"30 secondi"</item>
-    <item msgid="7589406073232279088">"1 minuto"</item>
-    <item msgid="7001195990902244174">"2 minuti"</item>
-    <item msgid="5721688686241190620">"10 minuti"</item>
-    <item msgid="7156442995039264948">"30 minuti"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"immediatamente"</item>
-    <item msgid="6736512735606834431">"5 secondi"</item>
-    <item msgid="8044619388267891375">"15 secondi"</item>
-    <item msgid="1822002388249545488">"30 secondi"</item>
-    <item msgid="8538071621211916519">"1 minuto"</item>
-    <item msgid="5663439580228932882">"2 minuti"</item>
-    <item msgid="7505084444184116101">"10 minuti"</item>
-    <item msgid="4621683909972069205">"30 minuti"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Molto lenta"</item>
     <item msgid="2361722960903353554">"Lenta"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Mai quando collegato"</item>
     <item msgid="1986753720941888596">"Mai"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Automatica"</item>
+    <item msgid="6670588712989942178">"Solo 5 GHz"</item>
+    <item msgid="2715516524973207876">"Solo 2,4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Tempo di utilizzo"</item>
     <item msgid="1908750532762193304">"Conteggio avvii"</item>
diff --git a/res/values-it/strings.xml b/res/values-it/strings.xml
index e5cda13..c5bc6fc 100644
--- a/res/values-it/strings.xml
+++ b/res/values-it/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Selettore dispositivo Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Richiesta autorizzazione Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Un\'applicazione sul tuo telefono chiede l\'autorizzazione per attivare Bluetooth. Procedere?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Un\'applicazione sul tuo telefono chiede l\'autorizzazione per rendere il tuo telefono rilevabile da altri dispositivi Bluetooth per <xliff:g id="TIMEOUT">%1$d</xliff:g> secondi. Procedere?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Un\'applicazione sul tuo telefono chiede l\'autorizzazione per rendere il tuo telefono rilevabile da altri dispositivi Bluetooth per <xliff:g id="TIMEOUT">%1$d</xliff:g> secondi. Procedere?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Un\'applicazione sul tuo telefono chiede l\'autorizzazione per attivare Bluetooth e rendere il tuo telefono rilevabile da altri dispositivi per <xliff:g id="TIMEOUT">%1$d</xliff:g> secondi. Procedere?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Un\'applicazione sul tuo telefono chiede l\'autorizzazione per attivare Bluetooth e rendere il tuo telefono rilevabile da altri dispositivi per <xliff:g id="TIMEOUT">%1$d</xliff:g> secondi. Procedere?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Attivazione Bluetooth in corso…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Impostazioni data e ora"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Sospensione Wi-Fi"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Specifica quando passare da Wi-Fi a dati cellulare"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Errore durante l\'impostazione dei criteri di sospensione."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Banda di frequenza Wi-Fi"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Specifica campo di frequenza di funzionamento"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Errore di impostazione della banda di frequenza."</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Indirizzo MAC"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Indirizzo IP"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"Impostazioni IP"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"Installa la scheda SD"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Cancella archivio USB"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"Cancella scheda SD"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Cancella i dati nell\'archivio USB interno del telefono, come musica e foto"</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Cancella i dati nell\'archivio USB interno, come musica e foto"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Cancella i dati nell\'archivio USB interno del telefono, come musica e foto"</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"Non disponibile"</string>
     <string name="read_only" msgid="6702420168629076340">" (Sola lettura)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Ripristino dati di fabbrica"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Cancella tutti i dati sul telefono"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Cancella tutti i dati sul telefono"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Questa operazione cancellerà tutti i dati dall\'"<b>"archivio interno"</b>" del Tablet PC, compresi:"\n\n<li>"L\'account Google"</li>\n<li>"I dati e le impostazioni di sistema e delle applicazioni"</li>\n<li>"Le applicazioni scaricate"</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Questa operazione cancellerà tutti i dati dall\'"<b>"archivio interno"</b>" del telefono, compresi:"\n\n<li>"L\'account Google"</li>\n<li>"I dati e le impostazioni di sistema e delle applicazioni"</li>\n<li>"Le applicazioni scaricate"</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Al momento sei collegato ai seguenti account:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Per cancellare anche musica, foto e altri dati dell\'utente, è necessario cancellare i dati dell\'"<b>"archivio USB"</b>"."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Cancella archivio USB"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Cancella scheda SD"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Cancella i dati nell\'archivio USB interno del telefono, come musica o foto."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Cancella i dati nell\'archivio USB interno del telefono, come musica o foto."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Cancella i dati nell\'archivio USB interno, come musica o foto."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Cancella i dati sulla scheda SD, come musica o foto."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Ripristina telefono"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Ripristina telefono"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"Cancellare tutte le tue informazioni personali e qualsiasi applicazione scaricata? Sarà impossibile annullare questa azione."</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Inserisci la sequenza di sblocco"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Per confermare un ripristino del telefono occorre inserire la sequenza di sblocco."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"Nessun ripristino eseguito perché il servizio System Clear non è disponibile."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Conferma reimpostazione"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Cancella archivio USB"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"Cancella scheda SD"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Cancella i dati nell\'arch. USB"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Utilizza GPS assistito"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"Utilizza il server per assistere il GPS (deseleziona per ridurre l\'utilizzo della rete)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"Utilizza il server per assistere il GPS (deseleziona per migliorare le prestazioni GPS)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"Utilizza La mia posizione"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Usa posizione per Ricerca Google"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Usa la posizione per Ricerca Google e per altri servizi Google"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"Posizione in uso per migliorare i risultati di ricerca di Google e altri servizi Google"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"Info sul telefono"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"Info sul telefono"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Visualizza informazioni legali, stato del telefono, versione del software"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Caricamento..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informazioni sulla sicurezza"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informazioni sulla sicurezza"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Il telefono non è collegato a un servizio dati. Per visualizzare ora le informazioni, accedi a %s da qualsiasi computer collegato a Internet."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Caricamento in corso..."</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Scegli la tua password"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Scegli il tuo PIN"</string>
diff --git a/res/values-ja/arrays.xml b/res/values-ja/arrays.xml
index 2862065..74e0a45 100644
--- a/res/values-ja/arrays.xml
+++ b/res/values-ja/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"ウィンドウアニメーションの一部を表示"</item>
     <item msgid="488968798204105119">"ウィンドウアニメーションをすべて表示"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15秒"</item>
-    <item msgid="8881760709354815449">"30秒"</item>
-    <item msgid="7589406073232279088">"1分"</item>
-    <item msgid="7001195990902244174">"2分"</item>
-    <item msgid="5721688686241190620">"10分"</item>
-    <item msgid="7156442995039264948">"30分"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"今すぐ"</item>
-    <item msgid="6736512735606834431">"5秒"</item>
-    <item msgid="8044619388267891375">"15秒"</item>
-    <item msgid="1822002388249545488">"30秒"</item>
-    <item msgid="8538071621211916519">"1分"</item>
-    <item msgid="5663439580228932882">"2分"</item>
-    <item msgid="7505084444184116101">"10分"</item>
-    <item msgid="4621683909972069205">"30分"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"非常に遅い"</item>
     <item msgid="2361722960903353554">"遅い"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"電源接続時はスリープにしない"</item>
     <item msgid="1986753720941888596">"スリープにしない"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"自動"</item>
+    <item msgid="6670588712989942178">"5 GHzのみ"</item>
+    <item msgid="2715516524973207876">"2.4 GHzのみ"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"使用時間"</item>
     <item msgid="1908750532762193304">"起動回数"</item>
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
index 4e370e3..ec44648 100644
--- a/res/values-ja/strings.xml
+++ b/res/values-ja/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Bluetooth端末の選択"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Bluetooth許可リクエスト"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"アプリケーションがBluetoothをONにする許可をリクエストしています。許可しますか？"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"アプリケーションが、この端末を<xliff:g id="TIMEOUT">%1$d</xliff:g>秒間他のBluetooth端末から検出できるようにする許可をリクエストしています。許可しますか？"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"アプリケーションが、この端末を<xliff:g id="TIMEOUT">%1$d</xliff:g>秒間他のBluetooth端末から検出できるようにする許可をリクエストしています。許可しますか？"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"アプリケーションが、BluetoothをONにしてこの端末を<xliff:g id="TIMEOUT">%1$d</xliff:g>秒間他の端末から検出できるようにする許可をリクエストしています。許可しますか？"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"アプリケーションが、BluetoothをONにしてこの端末を<xliff:g id="TIMEOUT">%1$d</xliff:g>秒間他の端末から検出できるようにする許可をリクエストしています。許可しますか？"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"BluetoothをONにしています..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"日付と時刻"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Wi-Fiのスリープ設定"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Wi-Fiをスリープに切り替えるタイミング"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"スリープポリシーの設定で問題が発生しました。"</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Wi-Fi周波数帯域"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"使用する周波数帯域を指定する"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"周波数帯域の設定中に問題が発生しました。"</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MACアドレス"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IPアドレス"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"IP設定"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"SDカードをマウント"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"USBストレージ内データを消去"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"SDカード内データを消去"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"内部USBストレージ内の全データ（音楽、写真など）を消去します。"</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"内部USBストレージ内の全データ（音楽、写真など）の消去"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"内部USBストレージ内の全データ（音楽、写真など）を消去します。"</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"使用不可"</string>
     <string name="read_only" msgid="6702420168629076340">" （読み取り専用）"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"データの初期化"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"携帯電話内のすべてのデータを消去"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"携帯電話内のすべてのデータを消去"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"この操作を行うと、以下のデータを含む"<b>"内部ストレージ"</b>"の全データが消去されます:"\n\n<li>"Googleアカウント"</li>\n<li>"システムやアプリケーションのデータと設定"</li>\n<li>"ダウンロードしたアプリケーション"</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"この操作を行うと、以下のデータを含む"<b>"内部ストレージ"</b>"の全データが消去されます:"\n\n<li>"Googleアカウント"</li>\n<li>"システムやアプリケーションのデータと設定"</li>\n<li>"ダウンロードしたアプリケーション"</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"以下のアカウントにログインしています:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"音楽、写真、その他のユーザーデータも消去する場合は"<b>"USBストレージ"</b>"を消去する必要があります。"</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"USBストレージ内データの消去"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"SDカード内データを消去"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"内部USBストレージ内の全データ（音楽、写真など）を消去します。"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"内部USBストレージ内の全データ（音楽、写真など）を消去します。"</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"内部USBストレージ内の全データ（音楽、写真など）を消去します。"</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"SDカード内の全データ（音楽、写真など）を消去します。"</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"携帯電話をリセット"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"携帯電話をリセット"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"個人情報とダウンロードしたアプリケーションをすべて削除しますか？この操作を元に戻すことはできません。"</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"ロック解除パターンを入力してください"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"携帯電話をリセットするには、ロック解除パターンを入力する必要があります。"</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"System Clearサービスが利用できないため、リセットされませんでした。"</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"リセットの確認"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"USBストレージ内データを消去"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"SDカード内データを消去"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"USBストレージ内の全データ消去"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"A-GPSを使用"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"サーバーでGPSを補助します（OFFにするとネットワーク使用率が減少します）"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"サーバーでGPSを補助します（OFFにするとGPS性能が向上します）"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"現在地情報を使用"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"現在地情報をGoogle検索に利用する"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"現在地情報をGoogleの検索やサービスで利用する"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"現在地をGoogleの検索結果やサービスの向上に利用する"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"端末情報"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"端末情報"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"端末情報、規約、バージョン情報"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"読み込み中..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"安全に関する情報"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"安全に関する情報"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"この電話はデータサービスに接続されていません。この情報を表示するにはインターネットに接続されたコンピュータから%sにアクセスしてください。"</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"読み込み中..."</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"パスワードを選択"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"PINを選択"</string>
diff --git a/res/values-ko/arrays.xml b/res/values-ko/arrays.xml
index 9b80b92..13e4d45 100644
--- a/res/values-ko/arrays.xml
+++ b/res/values-ko/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"일부 창 애니메이션이 표시됩니다."</item>
     <item msgid="488968798204105119">"모든 창 애니메이션이 표시됨"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15초"</item>
-    <item msgid="8881760709354815449">"30초"</item>
-    <item msgid="7589406073232279088">"1분"</item>
-    <item msgid="7001195990902244174">"2분"</item>
-    <item msgid="5721688686241190620">"10분"</item>
-    <item msgid="7156442995039264948">"30분"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"즉시"</item>
-    <item msgid="6736512735606834431">"5초"</item>
-    <item msgid="8044619388267891375">"15초"</item>
-    <item msgid="1822002388249545488">"30초"</item>
-    <item msgid="8538071621211916519">"1분"</item>
-    <item msgid="5663439580228932882">"2분"</item>
-    <item msgid="7505084444184116101">"10분"</item>
-    <item msgid="4621683909972069205">"30분"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"매우 느림"</item>
     <item msgid="2361722960903353554">"느림"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"전원에 연결되었을 때는 절전 모드로 전환되지 않음"</item>
     <item msgid="1986753720941888596">"절전 모드로 전환 안함"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"자동"</item>
+    <item msgid="6670588712989942178">"5GHz 전용"</item>
+    <item msgid="2715516524973207876">"2.4GHz 전용"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"사용 시간"</item>
     <item msgid="1908750532762193304">"계수 시작"</item>
diff --git a/res/values-ko/strings.xml b/res/values-ko/strings.xml
index b883f55..6cd3928 100644
--- a/res/values-ko/strings.xml
+++ b/res/values-ko/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Bluetooth 장치 선택기"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"블루투스 권한 요청"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"휴대전화의 애플리케이션에서 블루투스 사용 권한을 요청하고 있습니다. 사용하시겠습니까?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"휴대전화의 애플리케이션에서 <xliff:g id="TIMEOUT">%1$d</xliff:g>초 동안 다른 블루투스 장치에서 사용자의 휴대전화를 찾을 수 있는 권한을 요청하고 있습니다. 사용하시겠습니까?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"휴대전화의 애플리케이션에서 <xliff:g id="TIMEOUT">%1$d</xliff:g>초 동안 다른 블루투스 장치에서 사용자의 휴대전화를 찾을 수 있는 권한을 요청하고 있습니다. 사용하시겠습니까?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"휴대전화의 애플리케이션에서 블루투스 사용 및 <xliff:g id="TIMEOUT">%1$d</xliff:g>초 동안 다른 장치에서 사용자의 휴대전화를 찾을 수 있는 권한을 요청하고 있습니다. 사용하시겠습니까?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"휴대전화의 애플리케이션에서 블루투스 사용 및 <xliff:g id="TIMEOUT">%1$d</xliff:g>초 동안 다른 장치에서 사용자의 휴대전화를 찾을 수 있는 권한을 요청하고 있습니다. 사용하시겠습니까?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"블루투스 켜는 중..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"날짜 및 시간 설정"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Wi-Fi 절전 정책"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Wi-Fi에서 모바일 데이터로 전환될 때 표시"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"절전 정책을 설정하는 동안 문제가 발행했습니다."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Wi-Fi 주파수 대역"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"작업에 대한 주파수 범위 지정"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"주파수 대역을 설정하는 동안 문제가 발생했습니다."</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MAC 주소"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP 주소"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"IP 설정"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"SD 카드 마운트"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"USB 저장소 지우기"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"SD 카드 지우기"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"휴대전화의 내부 USB 저장소에 있는 모든 데이터(예: 음악 및 사진)를 지웁니다."</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"내부 USB 저장소에 있는 모든 데이터(예: 음악 및 사진)를 지웁니다."</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"휴대전화의 내부 USB 저장소에 있는 모든 데이터(예: 음악 및 사진)를 지웁니다."</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"사용할 수 없음"</string>
     <string name="read_only" msgid="6702420168629076340">" (읽기전용)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"기본값 데이터 재설정"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"휴대전화의 모든 데이터 지우기"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"휴대전화의 모든 데이터 지우기"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"이렇게 하면 태블릿의 "<b>"내부 저장소"</b>"("\n\n<li>"Google 계정"</li>\n<li>"시스템과 애플리케이션 데이터 및 설정"</li>\n<li>"다운로드된 애플리케이션"</li>" 포함)에서 모든 데이터가 삭제됩니다."</string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"이렇게 하면 휴대전화의 "<b>"내부 저장소"</b>"("\n\n<li>"Google 계정"</li>\n<li>"시스템과 애플리케이션 데이터 및 설정"</li>\n<li>"다운로드된 애플리케이션"</li>" 포함)에서 모든 데이터가 삭제됩니다."</string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"현재 다음 계정에 로그인함:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"음악이나 사진, 기타 사용자 데이터도 지우려면 "<b>"USB 저장소"</b>"를 삭제해야 합니다."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"USB 저장소 지우기"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"SD 카드 지우기"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"휴대전화기의 내부 USB 저장소에 있는 모든 데이터(예: 음악 또는 사진)를 지웁니다."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"휴대전화기의 내부 USB 저장소에 있는 모든 데이터(예: 음악 또는 사진)를 지웁니다."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"내부 USB 저장소에 있는 모든 데이터(예: 음악 또는 사진)를 지웁니다."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"SD 카드에 있는 모든 데이터(예: 음악 또는 사진)를 지웁니다."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"휴대전화 재설정"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"휴대전화 재설정"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"모든 개인 정보와 다운로드한 애플리케이션을 삭제하시겠습니까? 수행한 작업은 취소할 수 없습니다."</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"잠금해제 패턴을 그리세요."</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"휴대전화 재설정을 확인하려면 잠금해제 패턴을 그려야 합니다."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"시스템 지우기 서비스를 사용할 수 없어 재설정을 수행하지 못했습니다."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"재설정 확인"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"USB 저장소 지우기"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"SD 카드 지우기"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"USB 저장소의 모든 데이터 지우기"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"GPS 도우미 사용"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"서버를 사용하여 GPS 보조(네트워크 사용량을 줄이려면 선택 취소)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"서버를 사용하여 GPS 보조(GPS 성능을 개선하려면 선택 취소)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"내 위치 사용"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Google 검색에 위치 사용"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Google 검색 및 기타 Google 서비스에 위치 사용"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"Google 검색결과 및 기타 Google 서비스 개선을 위해 위치 사용"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"휴대전화 정보"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"휴대전화 정보"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"법률 정보, 휴대전화 상태, 소프트웨어 버전 보기"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"로드 중..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"안전 정보"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"안전 정보"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"휴대전화가 데이터 서비스에 연결되어 있지 않습니다. 지금 정보를 보려면 인터넷에 연결된 컴퓨터에서 %s(으)로 이동하세요."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"로드 중..."</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"비밀번호 선택"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"PIN 선택"</string>
@@ -940,7 +929,7 @@
     <string name="service_started_by_app" msgid="6575184738671598131">"애플리케이션에서 시작했습니다."</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> 무료"</string>
+    <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> 남음"</string>
     <string name="service_foreground_processes" msgid="7583975676795574276">"<xliff:g id="MEMORY">%1$s</xliff:g> 사용됨"</string>
     <string name="memory" msgid="6609961111091483458">"RAM"</string>
     <!-- no translation found for service_process_name (4098932168654826656) -->
diff --git a/res/values-lt/arrays.xml b/res/values-lt/arrays.xml
index 9254de4..4ae2a37 100644
--- a/res/values-lt/arrays.xml
+++ b/res/values-lt/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Rodomos kai kurios lango animacijos"</item>
     <item msgid="488968798204105119">"Rodoma visa lango animacija"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 sek."</item>
-    <item msgid="8881760709354815449">"30 sek."</item>
-    <item msgid="7589406073232279088">"1 min."</item>
-    <item msgid="7001195990902244174">"2 min."</item>
-    <item msgid="5721688686241190620">"10 min."</item>
-    <item msgid="7156442995039264948">"30 min."</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Labai lėtas"</item>
     <item msgid="2361722960903353554">"Lėtas"</item>
diff --git a/res/values-lt/strings.xml b/res/values-lt/strings.xml
index e5b4a4f..f0bc3e4 100644
--- a/res/values-lt/strings.xml
+++ b/res/values-lt/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"„Bluetooth“ įrenginio išrinkimo priemonė"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"„Bluetooth“ leidimo užklausa"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Telefone esanti programa prašo leidimo įjungti „Bluetooth“. Ar norite tai atlikti?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Jūsų telefone esanti programa prašo leidimo padaryti telefoną randamu kitiems „Bluetooth“·įrenginiams <xliff:g id="TIMEOUT">%1$d</xliff:g> sek. Ar norite tai daryti?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Jūsų telefone esanti programa prašo leidimo padaryti telefoną randamu kitiems „Bluetooth“·įrenginiams <xliff:g id="TIMEOUT">%1$d</xliff:g> sek. Ar norite tai daryti?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Telefone esanti programa prašo leidimo įjungti „Bluetooth“ ir padaryti telefoną randamą kitų įrenginių·<xliff:g id="TIMEOUT">%1$d</xliff:g> sek. Ar norite tai atlikti?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Telefone esanti programa prašo leidimo įjungti „Bluetooth“ ir padaryti telefoną randamą kitų įrenginių·<xliff:g id="TIMEOUT">%1$d</xliff:g> sek. Ar norite tai atlikti?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Įjungiamas „Bluetooth“..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"Datos ir laiko nustatymai"</string>
@@ -863,7 +865,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Įkeliama…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Saugos informacija"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Saugos informacija"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Telefonas neprijungtas prie duomenų paslaugų. Jei norite peržiūrėti šią informaciją, apsilankykite šiuo adresu: %s naudodami bet kurį prie interneto prijungtą kompiuterį."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Įkeliama…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Pasirinkite slaptažodį"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Pasirinkite PIN kodą"</string>
@@ -1012,12 +1015,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Pradėta programos: palieskite, kad sustabdytumėte"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-lv/arrays.xml b/res/values-lv/arrays.xml
index 9b38c01..3ae1b4b 100644
--- a/res/values-lv/arrays.xml
+++ b/res/values-lv/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Ir redzamas dažas loga animācijas"</item>
     <item msgid="488968798204105119">"IR redzamas visas loga animācijas"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 sekundes"</item>
-    <item msgid="8881760709354815449">"30 sekundes"</item>
-    <item msgid="7589406073232279088">"1 minūte"</item>
-    <item msgid="7001195990902244174">"2 minūtes"</item>
-    <item msgid="5721688686241190620">"10 minūtes"</item>
-    <item msgid="7156442995039264948">"30 minūtes"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Ļoti lēni"</item>
     <item msgid="2361722960903353554">"Lēni"</item>
diff --git a/res/values-lv/strings.xml b/res/values-lv/strings.xml
index 1424420..fbc8753 100644
--- a/res/values-lv/strings.xml
+++ b/res/values-lv/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Bluetooth ierīces atlasītājs"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Bluetooth atļaujas pieprasījums"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Jūsu tālruņa lietojumprogramma pieprasa atļauju ieslēgt Bluetooth. Vai vēlaties to darīt?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Jūsu tālruņa lietojumprogramma pieprasa atļauju padarīt jūsu tālruni atklājamu citām Bluetooth ierīcēm <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundes. Vai vēlaties to darīt?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Jūsu tālruņa lietojumprogramma pieprasa atļauju padarīt jūsu tālruni atklājamu citām Bluetooth ierīcēm <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundes. Vai vēlaties to darīt?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Jūsu tālruņa lietojumprogramma pieprasa atļauju ieslēgt Bluetooth un padarīt jūsu tālruni atklājamu citām ierīcēm <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundes. Vai vēlaties to darīt?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Jūsu tālruņa lietojumprogramma pieprasa atļauju ieslēgt Bluetooth un padarīt jūsu tālruni atklājamu citām ierīcēm <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundes. Vai vēlaties to darīt?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Notiek Bluetooth ieslēgšana…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Datuma un laika iestatījumi"</string>
@@ -863,7 +865,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Notiek ielāde…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informācija par drošību"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informācija par drošību"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Tālrunis nav savienots ar datu pakalpojumu. Lai tūlīt skatītu šo informāciju, pārejiet pie %s, izmantojot jebkuru datoru, kam ir interneta pieslēgums."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Notiek ielāde…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Paroles izvēle"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Izvēlieties PIN kodu"</string>
@@ -1012,12 +1015,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Lietojumprogrammas palaists: pieskarieties, lai apturētu"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-nb/arrays.xml b/res/values-nb/arrays.xml
index b9aa2b5..4cfa9fd 100644
--- a/res/values-nb/arrays.xml
+++ b/res/values-nb/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"Noen vindusanimasjoner vises"</item>
     <item msgid="488968798204105119">"Alle vindusanimasjoner vises"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 sekunder"</item>
-    <item msgid="8881760709354815449">"30 sekunder"</item>
-    <item msgid="7589406073232279088">"1 minutt"</item>
-    <item msgid="7001195990902244174">"2 minutter"</item>
-    <item msgid="5721688686241190620">"10 minutter"</item>
-    <item msgid="7156442995039264948">"30 minutter"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"umiddelbart"</item>
-    <item msgid="6736512735606834431">"5 sekunder"</item>
-    <item msgid="8044619388267891375">"15 sekunder"</item>
-    <item msgid="1822002388249545488">"30 sekunder"</item>
-    <item msgid="8538071621211916519">"1 minutt"</item>
-    <item msgid="5663439580228932882">"2 minutter"</item>
-    <item msgid="7505084444184116101">"10 minutter"</item>
-    <item msgid="4621683909972069205">"30 minutter"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Svært langsom"</item>
     <item msgid="2361722960903353554">"Langsom"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Aldri når tilkoblet"</item>
     <item msgid="1986753720941888596">"Aldri"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Automatisk"</item>
+    <item msgid="6670588712989942178">"Kun 5 GHz"</item>
+    <item msgid="2715516524973207876">"Kun 2,4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Brukstid"</item>
     <item msgid="1908750532762193304">"Start telling"</item>
diff --git a/res/values-nb/strings.xml b/res/values-nb/strings.xml
index 18f82a7..78299b9 100644
--- a/res/values-nb/strings.xml
+++ b/res/values-nb/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Bluetooths enhetsvelger"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Bluetooth-tillatelse"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"En applikasjon på telefonen spør om tillatelse til å slå på Bluetooth. Ønsker du å gjøre dette?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"En applikasjon på telefonen spør om tillatelse for å gjøre telefonen synlig for andre Bluetooth-enheter i <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunder. Ønsker du å gjøre dette?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"En applikasjon på telefonen spør om tillatelse for å gjøre telefonen synlig for andre Bluetooth-enheter i <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunder. Ønsker du å gjøre dette?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"En applikasjon på telefonen spør om tillatelse til å slå på Bluetooth og gjøre telefonen synlig for andre enheter i <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunder. Ønsker du å gjøre dette?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"En applikasjon på telefonen spør om tillatelse til å slå på Bluetooth og gjøre telefonen synlig for andre enheter i <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunder. Ønsker du å gjøre dette?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Aktiverer Bluetooth…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Innstillinger for dato og tid"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Soveinnstillinger for trådløst nett"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Spesifiser når telefonen skal bytte fra trådløsnett til mobiltelefonidata"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Det oppsto et problem under setting av soveinnstilling."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Wi-Fi-frekvensbånd"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Angi operasjonens frekvensområde"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Det oppsto et problem med frekvensbåndet."</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MAC-adresse"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP-adresse"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"IP-innstillinger"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"Koble til minnekortet"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Slett USB-lagring"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"Slett SD-kort"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Sletter intern USB-lagring."</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Sletter intern USB-lagring, som musikk og bilder"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Sletter intern USB-lagring."</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"Ikke tilgjengelig"</string>
     <string name="read_only" msgid="6702420168629076340">" (skrivebeskyttet)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Fabrikkinnstillinger"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Fjern alle data fra telefonen"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Fjern alle data fra telefonen"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Denne handlingen vil slette alle data fra tavlens"<b>"interne lagringsplass"</b>", inkludert:"\n\n<li>"Google-kontoen din"</li>\n<li>"Innstillinger og data for system og programmer"</li>\n<li>"Nedlastede programmer"</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Denne handlingen vil slette alle data fra telefonens"<b>"interne lagringsplass"</b>", inkludert:"\n\n<li>"Google-kontoen din"</li>\n<li>"Innstillinger og data for system og programmer"</li>\n<li>"Nedlastede programmer"</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Du er for øyeblikket pålogget følgende kontoer:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"For i tillegg å slette musikk, bilder og andre brukerdata, må "<b>"USB-lagringen"</b>" tømmes."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Slett USB-lagring"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Slett SD-kort"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Slett all intern USB-lagring."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Slett all intern USB-lagring."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Slett all intern USB-lagring, som for eksempel musikk eller bilder."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Slett alle data på SD-kort, som for eksempel musikk eller bilder."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Tilbakestill telefonen"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Tilbakestill telefonen"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"Fjern all personlig informasjon og nedlastede applikasjoner? Dette kan ikke gjøres om!"</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Tegn opplåsingsmønsteret"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Du må tegne opplåsingsmønsteret for å bekrefte tilbakestilling av telefonen."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"Telefonen ble ikke tilbakestilt fordi tilbakestillingstjenesten ikke er tilgjengelig."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Bekreft tilbakestillelse"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Slett USB-lagring"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"Slett SD-kort"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Sletter alle data i USB-lagr."</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Aktiver GPS med hjelp"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"Bruk tjener til å hjelpe GPS (opphev for å redusere nettverksbruken)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"Bruk tjeneren til å hjelpe GPS (velg for å forbedre GPS-ytelsen)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"Del med Google"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Bruk posisjon i Google Søk"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Bruk posisjonen din for bedre søk og andre tjenester"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"Min posisjon brukes til å forbedre søkeresultater og andre tjenester"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"Om telefonen"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"Om telefonen"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Vis juridisk informasjon, telefonstatus, programvareversjon"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"henter…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Sikkerhetsinformasjon"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Sikkerhetsinformasjon"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Telefonen er ikke koblet til en datatjeneste. For å se informasjonen nå, gå til %s fra en datamaskin koblet til internett."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Henter…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Velg passord"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Velg PIN-kode"</string>
diff --git a/res/values-nl/arrays.xml b/res/values-nl/arrays.xml
index 7217a94..73ea23a 100644
--- a/res/values-nl/arrays.xml
+++ b/res/values-nl/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"Er worden een paar vensteranimaties weergegeven"</item>
     <item msgid="488968798204105119">"Alle vensteranimaties worden weergegeven"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 seconden"</item>
-    <item msgid="8881760709354815449">"30 seconden"</item>
-    <item msgid="7589406073232279088">"1 minuut"</item>
-    <item msgid="7001195990902244174">"2 minuten"</item>
-    <item msgid="5721688686241190620">"10 minuten"</item>
-    <item msgid="7156442995039264948">"30 minuten"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"onmiddellijk"</item>
-    <item msgid="6736512735606834431">"5 seconden"</item>
-    <item msgid="8044619388267891375">"15 seconden"</item>
-    <item msgid="1822002388249545488">"30 seconden"</item>
-    <item msgid="8538071621211916519">"1 minuut"</item>
-    <item msgid="5663439580228932882">"2 minuten"</item>
-    <item msgid="7505084444184116101">"10 minuten"</item>
-    <item msgid="4621683909972069205">"30 minuten"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Zeer langzaam"</item>
     <item msgid="2361722960903353554">"Langzaam"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Nooit indien aangesloten"</item>
     <item msgid="1986753720941888596">"Nooit"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Automatisch"</item>
+    <item msgid="6670588712989942178">"Alleen 5 GHz"</item>
+    <item msgid="2715516524973207876">"Alleen 2,4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Gebruikstijd"</item>
     <item msgid="1908750532762193304">"Aantal keer gestart"</item>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index 2a0f965..fadce56 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Apparaatkiezer van Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Machtigingsverzoek voor Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Een toepassing probeert Bluetooth in te schakelen. Wilt u dit toestaan?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Een toepassing probeert uw telefoon <xliff:g id="TIMEOUT">%1$d</xliff:g> seconden zichtbaar te maken voor andere Bluetooth-apparaten. Wilt u dit toestaan?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Een toepassing probeert uw telefoon <xliff:g id="TIMEOUT">%1$d</xliff:g> seconden zichtbaar te maken voor andere Bluetooth-apparaten. Wilt u dit toestaan?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Een toepassing probeert Bluetooth in te schakelen en uw telefoon <xliff:g id="TIMEOUT">%1$d</xliff:g> seconden zichtbaar te maken voor andere apparaten. Wilt u dit toestaan?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Een toepassing probeert Bluetooth in te schakelen en uw telefoon <xliff:g id="TIMEOUT">%1$d</xliff:g> seconden zichtbaar te maken voor andere apparaten. Wilt u dit toestaan?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Bluetooth inschakelen…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Datum- en tijdinstellingen"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Wi-Fi-slaapbeleid"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Overschakelen opgeven van Wi-Fi naar mobiele gegevens"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Er is een probleem opgetreden bij het instellen van het slaapbeleid."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Wi-Fi-frequentieband"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Het frequentiebereik voor gebruik opgeven"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Probleem bij instellen van het frequentiebeleid."</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MAC-adres"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP-adres"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"IP-instellingen"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"De SD-kaart koppelen"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"USB-opslag wissen"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"SD-kaart wissen"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Hiermee worden alle gegevens in de interne USB-opslag van de telefoon gewist, zoals muziek en foto\'s"</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Wist alle gegevens in de interne USB-opslag, zoals muziek en foto\'s"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Hiermee worden alle gegevens in de interne USB-opslag van de telefoon gewist, zoals muziek en foto\'s"</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"Niet beschikbaar"</string>
     <string name="read_only" msgid="6702420168629076340">" (Alleen-lezen)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Fabrieksinstellingen terug"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Alle gegevens op de telefoon wissen"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Alle gegevens op de telefoon wissen"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Hiermee worden alle gegevens in de "<b>"interne opslag"</b>" van uw tablet gewist, waaronder:"\n\n<li>"Uw Google-account"</li>\n<li>"Gegevens en instellingen van het systeem en de toepassingen"</li>\n<li>"Gedownloade toepassingen"</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Hiermee worden alle gegevens in de "<b>"interne opslag"</b>" van uw telefoon gewist, waaronder:"\n\n<li>"Uw Google-account"</li>\n<li>"Gegevens en instellingen van het systeem en de toepassingen"</li>\n<li>"Gedownloade toepassingen"</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"U bent momenteel aangemeld bij de volgende accounts:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Als u ook muziek, foto\'s en andere gebruikersgegevens wilt wissen, moet de "<b>"USB-opslag"</b>" worden gewist."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"USB-opslag wissen"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"SD-kaart wissen"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Alle gegevens in de interne USB-opslag van de telefoon wissen, zoals muziek en foto\'s."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Alle gegevens in de interne USB-opslag van de telefoon wissen, zoals muziek en foto\'s."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Alle gegevens in de interne USB-opslag wissen, zoals muziek en foto\'s."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Alle gegevens op de SD-kaart wissen, zoals muziek en foto\'s."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Telefoon opnieuw instellen"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Telefoon opnieuw instellen"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"Alle persoonlijke gegevens en gedownloade toepassingen wissen? U kunt deze actie niet ongedaan maken."</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Teken uw ontgrendelingspatroon"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"U moet uw ontgrendelingspatroon tekenen om het opnieuw instellen van de telefoon te bevestigen."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"Niet opnieuw ingesteld, omdat de service \'Systeem wissen\' niet beschikbaar is."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Opnieuw instellen bevestigen"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"USB-opslag wissen"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"SD-kaart wissen"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Alle gegevens in USB-opslag wissen"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Ondersteunde GPS gebruiken"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"Server gebruiken ter ondersteuning van GPS (uitschakelen om het netwerkgebruik te beperken)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"Server gebruiken ter ondersteuning van GPS (uitschakelen om GPS-prestaties te verbeteren)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"\'Mijn locatie\' gebruiken"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Locatie gebruiken voor Google Zoeken"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Locatie gebruiken voor Google Zoeken en andere Google-services"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"Locatie wordt gebruikt om Google-zoekresultaten en andere Google-services te verbeteren"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"Over de telefoon"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"Over de telefoon"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Juridische info, telefoonstatus, softwareversie weergeven"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Laden..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Veiligheidsinformatie"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Veiligheidsinformatie"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Uw telefoon heeft geen verbinding met een gegevensservice. Als u deze informatie nu wilt weergeven, gaat u op een computer met internetverbinding naar %s."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Laden..."</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Uw wachtwoord kiezen"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Uw PIN-code kiezen"</string>
diff --git a/res/values-pl/arrays.xml b/res/values-pl/arrays.xml
index 19c517c..1195873 100644
--- a/res/values-pl/arrays.xml
+++ b/res/values-pl/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"Niektóre animacje okien są wyświetlane"</item>
     <item msgid="488968798204105119">"Wszystkie animacje okien są wyświetlane"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 sekund"</item>
-    <item msgid="8881760709354815449">"30 sekund"</item>
-    <item msgid="7589406073232279088">"1 minuta"</item>
-    <item msgid="7001195990902244174">"2 minuty"</item>
-    <item msgid="5721688686241190620">"10 minut"</item>
-    <item msgid="7156442995039264948">"30 minut"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"natychmiast"</item>
-    <item msgid="6736512735606834431">"5 sekund"</item>
-    <item msgid="8044619388267891375">"15 sekund"</item>
-    <item msgid="1822002388249545488">"30 sekund"</item>
-    <item msgid="8538071621211916519">"1 minuta"</item>
-    <item msgid="5663439580228932882">"2 minuty"</item>
-    <item msgid="7505084444184116101">"10 minut"</item>
-    <item msgid="4621683909972069205">"30 minut"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Bardzo wolno"</item>
     <item msgid="2361722960903353554">"Wolno"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Nigdy, gdy podłączony"</item>
     <item msgid="1986753720941888596">"Nigdy"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Automatyczna"</item>
+    <item msgid="6670588712989942178">"Tylko 5 GHz"</item>
+    <item msgid="2715516524973207876">"Tylko 2,4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Czas użycia"</item>
     <item msgid="1908750532762193304">"Licznik uruchomień"</item>
diff --git a/res/values-pl/strings.xml b/res/values-pl/strings.xml
index e4c04d6..498940b 100644
--- a/res/values-pl/strings.xml
+++ b/res/values-pl/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Selektor urządzenia Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Prośba o pozwolenie na włączenie modułu Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Aplikacja w telefonie prosi o pozwolenie na włączenie modułu Bluetooth. Czy chcesz na to zezwolić?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Aplikacja w telefonie prosi o pozwolenie na ustawienie telefonu jako wykrywalnego przez inne urządzenia Bluetooth na czas <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Czy chcesz na to zezwolić?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Aplikacja w telefonie prosi o pozwolenie na ustawienie telefonu jako wykrywalnego przez inne urządzenia Bluetooth na czas <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Czy chcesz na to zezwolić?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Aplikacja w telefonie prosi o pozwolenie na włączenie modułu Bluetooth i ustawienie telefonu jako wykrywalnego przez inne urządzenia na czas <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Czy chcesz na to zezwolić?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Aplikacja w telefonie prosi o pozwolenie na włączenie modułu Bluetooth i ustawienie telefonu jako wykrywalnego przez inne urządzenia na czas <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Czy chcesz na to zezwolić?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Trwa włączanie modułu Bluetooth..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"Ustawienia daty i godziny"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Zasady usypiania Wi-Fi"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Określ, kiedy przełączyć Wi-Fi na komórkowe połączenie danych"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Wystąpił problem podczas ustawiania zasad usypiania."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Pasmo częstotliwości sieci Wi-Fi"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Określ używany zakres częstotliwości"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Wystąpił problem podczas ustawiania częstotliwości."</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Adres MAC"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Adres IP"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"Ustawienia IP"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"Zainstaluj kartę SD"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Wyczyść nośnik USB"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"Wyczyść kartę SD"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Wymazuje wszystko z wewn. USB"</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Wymazuje wszystkie dane z wewnętrznego nośnika USB, np. pliki muzyczne i zdjęcia"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Wymazuje wszystko z wewn. USB"</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"Niedostępna"</string>
     <string name="read_only" msgid="6702420168629076340">" (Tylko do odczytu)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Ustawienia fabryczne"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Wymazuje wszystkie dane w telefonie"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Wymazuje wszystkie dane w telefonie"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Spowoduje to wymazanie wszystkich danych z "<b>"wewnętrznej pamięci"</b>" tabletu, w tym:"\n\n<li>"danych konta Google,"</li>\n<li>"danych i ustawień systemu oraz aplikacji,"</li>\n<li>"pobranych aplikacji."</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Spowoduje to wymazanie wszystkich danych z "<b>"wewnętrznej pamięci"</b>" telefonu, w tym:"\n\n<li>"danych konta Google,"</li>\n<li>"danych i ustawień systemu oraz aplikacji,"</li>\n<li>"pobranych aplikacji."</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Zalogowano się na następujące konta:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Aby usunąć również muzykę, zdjęcia i inne dane użytkownika, należy wymazać "<b>"nośnik USB"</b>"."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Wyczyść nośnik USB"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Wyczyść kartę SD"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Wymaż wszystko z wewn. USB."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Wymaż wszystko z wewn. USB."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Wymaż wszystkie dane z wewnętrznego nośnika USB, np. pliki muzyczne i zdjęcia."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Wymaż wszystkie dane z karty SD, np. pliki muzyczne i zdjęcia."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Resetuj telefon"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Resetuj telefon"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"Czy usunąć wszystkie informacje osobiste i wszystkie pobrane aplikacje? Tej operacji nie można cofnąć!"</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Narysuj wzór odblokowania"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Aby potwierdzić resetowanie telefonu, musisz narysować swój wzór odblokowania."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"Nie wykonano resetowania, ponieważ usługa czyszczenia systemu nie jest dostępna."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Potwierdź resetowanie"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Wyczyść nośnik USB"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"Wyczyść kartę SD"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Wymazuje wszystko z nośnika USB"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Użyj wspomaganego systemu GPS"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"Użyj serwera do wspomagania systemu GPS (usuń zaznaczenie, aby zmniejszyć ruch sieciowy)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"Użyj serwera do wspomagania systemu GPS (usuń zaznaczenie, aby zwiększyć wydajność systemu GPS)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"Użyj funkcji Moja lokalizacja"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Użyj informacji o lokalizacji na potrzeby wyszukiwarki Google"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Użyj informacji o lokalizacji na potrzeby wyszukiwarki Google oraz innych usług Google"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"Informacje o lokalizacji są używane na potrzeby wyników wyszukiwania Google oraz innych usług Google"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"Informacje o telefonie"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"Informacje o telefonie"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Wyświetl informacje prawne, stan telefonu, wersję oprogramowania"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Ładowanie..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informacje o bezpieczeństwie"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informacje o bezpieczeństwie"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Telefon nie jest połączony z usługą transmisji danych. Aby wyświetlić te informacje teraz, przejdź do strony %s na dowolnym komputerze połączonym z internetem."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Trwa wczytywanie..."</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Wybierz hasło"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Wybierz kod PIN"</string>
diff --git a/res/values-pt-rPT/arrays.xml b/res/values-pt-rPT/arrays.xml
index d78533b..60cc7d6 100644
--- a/res/values-pt-rPT/arrays.xml
+++ b/res/values-pt-rPT/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"São apresentadas algumas animações de janela"</item>
     <item msgid="488968798204105119">"São apresentadas todas as animações de janela"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 segundos"</item>
-    <item msgid="8881760709354815449">"30 segundos"</item>
-    <item msgid="7589406073232279088">"1 minuto"</item>
-    <item msgid="7001195990902244174">"2 minutos"</item>
-    <item msgid="5721688686241190620">"10 minutos"</item>
-    <item msgid="7156442995039264948">"30 minutos"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"imediatamente"</item>
-    <item msgid="6736512735606834431">"5 segundos"</item>
-    <item msgid="8044619388267891375">"15 segundos"</item>
-    <item msgid="1822002388249545488">"30 segundos"</item>
-    <item msgid="8538071621211916519">"1 minuto"</item>
-    <item msgid="5663439580228932882">"2 minutos"</item>
-    <item msgid="7505084444184116101">"10 minutos"</item>
-    <item msgid="4621683909972069205">"30 minutos"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Muito lenta"</item>
     <item msgid="2361722960903353554">"Lenta"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Nunca quando ligado"</item>
     <item msgid="1986753720941888596">"Nunca"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Automático"</item>
+    <item msgid="6670588712989942178">"Apenas 5 GHz"</item>
+    <item msgid="2715516524973207876">"Apenas 2,4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Tempo de utilização"</item>
     <item msgid="1908750532762193304">"Total de inícios"</item>
diff --git a/res/values-pt-rPT/strings.xml b/res/values-pt-rPT/strings.xml
index 8335fab..f13d09c 100644
--- a/res/values-pt-rPT/strings.xml
+++ b/res/values-pt-rPT/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Seleccionador de dispositivo Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Pedido de emparelhamento de Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Uma aplicação no seu telefone está a solicitar autorização para activar o Bluetooth. Pretende fazê-lo?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Uma aplicação do seu telefone está a solicitar autorização para que o seu telefone possa ser detectado por outros dispositivos Bluetooth durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. Pretende fazê-lo?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Uma aplicação do seu telefone está a solicitar autorização para que o seu telefone possa ser detectado por outros dispositivos Bluetooth durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. Pretende fazê-lo?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Uma aplicação do seu telefone está a solicitar autorização para activar o Bluetooth e para que o seu telefone possa ser detectado por outros dispositivos durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. Pretende fazê-lo?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Uma aplicação do seu telefone está a solicitar autorização para activar o Bluetooth e para que o seu telefone possa ser detectado por outros dispositivos durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. Pretende fazê-lo?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"A ligar Bluetooth..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"Definições de data e hora"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Política de suspensão Wi-Fi"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Especificar quando mudar de Wi-Fi para dados móveis"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Ocorreu um problema ao definir a política de suspensão."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Banda de frequência Wi-Fi"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Especifique o intervalo de frequência de operação"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Problema ao definir a banda de frequência."</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Endereço MAC"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Endereço IP"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"Definições de IP"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"Instalar cartão SD"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Apagar armazenamento USB"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"Apagar cartão SD"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Apaga todos os dados no armaz. USB interno do telemóvel, como músicas ou fotografias"</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Apaga todos os dados do armazenamento USB interno, como músicas e fotografias"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Apaga todos os dados no armaz. USB interno do telemóvel, como músicas ou fotografias"</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"Indisponível"</string>
     <string name="read_only" msgid="6702420168629076340">" (Só de leitura)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Reposição dos dados de fábrica"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Apaga todos os dados do telefone"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Apaga todos os dados do telefone"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Serão apagados todos os dados do "<b>"armazenamento interno"</b>" do tablet, incluindo:"\n\n<li>"A sua conta Google"</li>\n<li>"Dados e definições do sistema e das aplicações"</li>\n<li>"Aplicações transferidas"</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Serão apagados todos os dados do "<b>"armazenamento interno"</b>" do telefone, incluindo:"\n\n<li>"A sua conta Google"</li>\n<li>"Dados e definições do sistema e das aplicações"</li>\n<li>"Aplicações transferidas"</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Actualmente, tem sessão iniciada nas seguintes contas:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Para limpar também músicas, imagens e outros dados do utilizador, é necessário apagar o "<b>"armazenamento USB"</b>"."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Apagar armazenamento USB"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Apagar cartão SD"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Apaga todos os dados no armaz. USB interno do telemóvel, tais como músicas ou fotografias."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Apaga todos os dados no armaz. USB interno do telemóvel, tais como músicas ou fotografias."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Apaga todos os dados do armazenamento USB interno, como músicas ou fotografias."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Apaga todos os dados do cartão SD, como músicas ou fotografias."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Repor telefone"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Repor telefone"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"Apagar todas as informações pessoais e as aplicações transferidas? Não é possível reverter esta acção!"</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Desenhe o seu padrão de desbloqueio"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Tem de desenhar o seu padrão de desbloqueio para confirmar uma reposição do telefone."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"Não  foi efectuada nenhuma reposição porque o serviço System Clear não está disponível."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Confirmar reposição"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Apagar armazenamento USB"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"Apagar cartão SD"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Apaga todos dados armaz. USB"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Utilizar GPS assistido"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"Utilizar o servidor para auxiliar o GPS (desmarque esta opção para reduzir a utilização da rede)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"Utilizar o servidor para auxiliar o GPS (desmarque esta opção para melhorar o desempenho do GPS)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"Utilizar A minha localização"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Usar localização para pesquisa Google"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Usar A minha localização para a pesquisa Google e outros serviços Google"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"Localização utilizada para melhorar os resultados de pesquisa do Google e outros serviços Google"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"Acerca do telefone"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"Acerca do telefone"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Ver informações jurídicas, estado do telefone, versão de software"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"A carregar..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informações de segurança"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informações de segurança"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"O seu telefone não se encontra ligado a um serviço de dados. Para ver esta informação agora, aceda a %s a partir de qualquer computador ligado à Internet."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"A carregar..."</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Escolher palavra-passe"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Escolha o PIN"</string>
diff --git a/res/values-pt/arrays.xml b/res/values-pt/arrays.xml
index 27232ff..4d89f41 100644
--- a/res/values-pt/arrays.xml
+++ b/res/values-pt/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"Algumas animações de janela são exibidas"</item>
     <item msgid="488968798204105119">"Todas as animações de janela são exibidas"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 segundos"</item>
-    <item msgid="8881760709354815449">"30 segundos"</item>
-    <item msgid="7589406073232279088">"1 minuto"</item>
-    <item msgid="7001195990902244174">"2 minutos"</item>
-    <item msgid="5721688686241190620">"10 minutos"</item>
-    <item msgid="7156442995039264948">"30 minutos"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"imediatamente"</item>
-    <item msgid="6736512735606834431">"5 segundos"</item>
-    <item msgid="8044619388267891375">"15 segundos"</item>
-    <item msgid="1822002388249545488">"30 segundos"</item>
-    <item msgid="8538071621211916519">"1 minuto"</item>
-    <item msgid="5663439580228932882">"2 minutos"</item>
-    <item msgid="7505084444184116101">"10 minutos"</item>
-    <item msgid="4621683909972069205">"30 minutos"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Muito devagar"</item>
     <item msgid="2361722960903353554">"Devagar"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Nunca quando conectado"</item>
     <item msgid="1986753720941888596">"Nunca"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Automático"</item>
+    <item msgid="6670588712989942178">"Apenas 5 GHz"</item>
+    <item msgid="2715516524973207876">"Apenas 2,4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Tempo de uso"</item>
     <item msgid="1908750532762193304">"Iniciar contagem"</item>
diff --git a/res/values-pt/strings.xml b/res/values-pt/strings.xml
index cf0bcb9..e8059f2 100644
--- a/res/values-pt/strings.xml
+++ b/res/values-pt/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Selecionador de dispositivo Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Solicitação de permissão para Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Um aplicativo no seu telefone está solicitando permissão para ativar o Bluetooth. Deseja fazer isso?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Um aplicativo no seu telefone está solicitando permissão para tornar o seu telefone detectável por outros dispositivos Bluetooth por <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. Deseja fazer isso?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Um aplicativo no seu telefone está solicitando permissão para tornar o seu telefone detectável por outros dispositivos Bluetooth por <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. Deseja fazer isso?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Um aplicativo no seu telefone está solicitando permissão para ativar o Bluetooth e tornar o seu telefone detectável por outros dispositivos por <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. Deseja fazer isso?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Um aplicativo no seu telefone está solicitando permissão para ativar o Bluetooth e tornar o seu telefone detectável por outros dispositivos por <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos. Deseja fazer isso?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Ativando Bluetooth…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Configurações de data e hora"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Política de inatividade de Wi-Fi"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Especificar quando alternar de Wi-Fi para dados móveis"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Houve um problema ao configurar a política de inatividade"</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Banda de frequência Wi-Fi"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Especifique a faixa de frequência da operação"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Houve um erro ao configurar a banda de frequência."</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Endereço MAC"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Endereço IP"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"Configurações de IP"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"Conectar o cartão SD"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Apagar armazenamento USB"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"Apagar cartão SD"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Ap. arm. USB, como mús. e fot."</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Apaga todos os dados do armazenamento USB interno, como músicas e fotos"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Ap. arm. USB, como mús. e fot."</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"Não disponível"</string>
     <string name="read_only" msgid="6702420168629076340">" (Somente leitura)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Configuração original"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Apaga todos os dados no telefone"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Apaga todos os dados no telefone"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Esta ação apagará todos os dados do "<b>"armazenamento interno"</b>" do seu tablet, incluindo:"\n\n<li>"Sua Conta do Google"</li>\n<li>"Configurações e dados de aplicativos e sistema "</li>\n<li>"Aplicativos que você fez download"</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Esta ação apagará todos os dados do "<b>"armazenamento interno"</b>" do seu telefone, incluindo:"\n\n<li>"Sua Conta do Google"</li>\n<li>"Configurações e dados de aplicativos e sistema "</li>\n<li>"Aplicativos que você fez download"</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"No momento você está conectado às seguintes contas:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Para também limpar músicas, fotos e outros dados de usuário, o "<b>"armazenamento USB"</b>" precisa ser apagado."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Apagar armazenamento USB"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Apagar cartão SD"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Ap. arm. USB, como mús. e fot."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Ap. arm. USB, como mús. e fot."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Apagar todos os dados do armazenamento USB interno, como músicas e fotos."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Apagar todos os dados do cartão SD, como músicas e fotos."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Redefinir telefone"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Redefinir telefone"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"Apagar todas as informações pessoais e os aplicativos dos quais você fez download? É impossível reverter essa ação."</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Desenhe o seu padrão de desbloqueio"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Você precisa desenhar o seu padrão de desbloqueio para confirmar uma redefinição de telefone."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"Nenhuma redefinição foi realizada porque o serviço de Limpeza do sistema não está disponível."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Confirmar redefinição"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Apagar armazenamento USB"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"Apagar cartão SD"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Apaga dados do armazen. USB"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Usar GPS associado"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"Usar servidor para auxiliar GPS (desmarque para reduzir o uso da rede)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"Usar servidor para auxiliar GPS (desmarque para aprimorar o desempenho do GPS)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"Usar Meu Local"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Usar local para a pesquisa do Google"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Usar local para a pesquisa do Google e outros serviços do Google"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"Local usado para aprimorar resultados da pesquisa do Google e outros serviços do Google"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"Sobre o telefone"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"Sobre o telefone"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Ver informações legais, status do telefone, versão do software"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Carregando..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informações de segurança"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informações de segurança"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"O telefone não está conectado ao serviço de dados. Para visualizar estas informações agora, acesse %s em qualquer computador conectado à internet."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Carregando..."</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Escolha a sua senha"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Escolha o seu PIN"</string>
diff --git a/res/values-rm/arrays.xml b/res/values-rm/arrays.xml
index 569b5b9..3463279 100644
--- a/res/values-rm/arrays.xml
+++ b/res/values-rm/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Tschertas animaziuns da fanestras vegnan mussadas."</item>
     <item msgid="488968798204105119">"Tut las animaziuns da fanestras vegnan mussadas"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 secundas"</item>
-    <item msgid="8881760709354815449">"30 secundas"</item>
-    <item msgid="7589406073232279088">"1 minuta"</item>
-    <item msgid="7001195990902244174">"2 minutas"</item>
-    <item msgid="5721688686241190620">"10 minutas"</item>
-    <item msgid="7156442995039264948">"30 minutas"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Fitg plaun"</item>
     <item msgid="2361722960903353554">"Plaun"</item>
diff --git a/res/values-rm/strings.xml b/res/values-rm/strings.xml
index d49b6eb..7a5d5a5 100644
--- a/res/values-rm/strings.xml
+++ b/res/values-rm/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Tscherna dad apparats bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Dumonda d\'autorisaziun Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Ina applicaziun sin Voss telefon dumonda l\'autorisaziun dad activar bluetooth. Permetter?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Ina applicaziun sin Voss telefonin dumonda l\'autorisaziun dad activar la visibilitad da Voss telefonin per auters apparats da bluetooth durant <xliff:g id="TIMEOUT">%1$d</xliff:g> secundas. Vulais Vus quai?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Ina applicaziun sin Voss telefonin dumonda l\'autorisaziun dad activar la visibilitad da Voss telefonin per auters apparats da bluetooth durant <xliff:g id="TIMEOUT">%1$d</xliff:g> secundas. Vulais Vus quai?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Ina applicaziun sin Voss telefonin dumonda l\'autorisaziun dad activar bluetooth e far visibel Voss telefonin per auters apparats durant <xliff:g id="TIMEOUT">%1$d</xliff:g> secundas. Vulais Vus quai?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Ina applicaziun sin Voss telefonin dumonda l\'autorisaziun dad activar bluetooth e far visibel Voss telefonin per auters apparats durant <xliff:g id="TIMEOUT">%1$d</xliff:g> secundas. Vulais Vus quai?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Bluetooth vegn activà…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Parameters da data e da temp"</string>
@@ -833,7 +835,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Chargiar…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Infurmaziuns da segirezza"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Infurmaziuns da segirezza"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"\"Voss telefon n\'è betg connectà cun in servetsch da datas. Per consultar ussa questas infurmaziuns, accedi a %s cun agid d\'in computer cun access a l\'internet.\""</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Chargiar…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Tscherner Voss pled-clav"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Tscherner Voss PIN"</string>
@@ -976,8 +979,10 @@
     <string name="service_started_by_app" msgid="6575184738671598131">"Servetsch avià da l\'applicaziun"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- outdated translation 4939976652114824214 -->     <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> disponibel"</string>
-    <!-- outdated translation 2474726487867913314 -->     <string name="service_foreground_processes" msgid="7583975676795574276">"<xliff:g id="MEMORY">%1$s</xliff:g> vegnan utilisads"</string>
+    <!-- no translation found for service_background_processes (6844156253576174488) -->
+    <skip />
+    <!-- no translation found for service_foreground_processes (7583975676795574276) -->
+    <skip />
     <!-- no translation found for memory (6609961111091483458) -->
     <skip />
     <!-- no translation found for service_process_name (4098932168654826656) -->
diff --git a/res/values-ro/arrays.xml b/res/values-ro/arrays.xml
index 35522da..d448d7b 100644
--- a/res/values-ro/arrays.xml
+++ b/res/values-ro/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Sunt afişate anumite animaţii în fereastră"</item>
     <item msgid="488968798204105119">"Sunt afişate toate animaţiile pentru ferestre"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 secunde"</item>
-    <item msgid="8881760709354815449">"30 de secunde"</item>
-    <item msgid="7589406073232279088">"1 minut"</item>
-    <item msgid="7001195990902244174">"2 minute"</item>
-    <item msgid="5721688686241190620">"10 minute"</item>
-    <item msgid="7156442995039264948">"30 de minute"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Foarte încet"</item>
     <item msgid="2361722960903353554">"Încet"</item>
diff --git a/res/values-ro/strings.xml b/res/values-ro/strings.xml
index 1640397..39373af 100644
--- a/res/values-ro/strings.xml
+++ b/res/values-ro/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Selector de dispozitive Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Solicitare de permisiune Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"O aplicaţie de pe telefonul dvs. solicită permisiunea de a activa Bluetooth. Doriţi să faceţi acest lucru?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"O aplicaţie de pe telefonul dvs. solicită permisiunea de a seta telefonul dvs. ca detectabil de către alte dispozitive Bluetooth pentru <xliff:g id="TIMEOUT">%1$d</xliff:g> (de) secunde. Doriţi să faceţi acest lucru?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"O aplicaţie de pe telefonul dvs. solicită permisiunea de a seta telefonul dvs. ca detectabil de către alte dispozitive Bluetooth pentru <xliff:g id="TIMEOUT">%1$d</xliff:g> (de) secunde. Doriţi să faceţi acest lucru?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"O aplicaţie de pe telefonul dvs. solicită permisiunea de a activa Bluetooth şi să seteze telefonul dvs. ca detectabil de către alte dispozitive timp de <xliff:g id="TIMEOUT">%1$d</xliff:g> (de) secunde. Doriţi să faceţi acest lucru?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"O aplicaţie de pe telefonul dvs. solicită permisiunea de a activa Bluetooth şi să seteze telefonul dvs. ca detectabil de către alte dispozitive timp de <xliff:g id="TIMEOUT">%1$d</xliff:g> (de) secunde. Doriţi să faceţi acest lucru?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Se activează Bluetooth..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"Setări privind data şi ora"</string>
@@ -863,7 +865,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Se încarcă…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informaţii privind siguranţa"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informaţii privind siguranţa"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Telefonul dvs. nu este conectat la un serviciu de date. Pentru a vedea acum această informaţie, accesaţi %s de la orice computer conectat la internet."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Se încarcă…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Alegeţi parola"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Alegeţi codul PIN"</string>
@@ -1012,12 +1015,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Pornit de aplicaţie: atingeţi pentru a opri"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-ru/arrays.xml b/res/values-ru/arrays.xml
index 03023bc..a1d3353 100644
--- a/res/values-ru/arrays.xml
+++ b/res/values-ru/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"В окне отображается некоторая часть анимации"</item>
     <item msgid="488968798204105119">"Плавные переходы при переключении между окнами"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 секунд"</item>
-    <item msgid="8881760709354815449">"30 секунд"</item>
-    <item msgid="7589406073232279088">"1 минута"</item>
-    <item msgid="7001195990902244174">"2 минуты"</item>
-    <item msgid="5721688686241190620">"10 минут"</item>
-    <item msgid="7156442995039264948">"30 минут"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"немедленно"</item>
-    <item msgid="6736512735606834431">"5 сек"</item>
-    <item msgid="8044619388267891375">"15 сек"</item>
-    <item msgid="1822002388249545488">"30 сек"</item>
-    <item msgid="8538071621211916519">"1 мин"</item>
-    <item msgid="5663439580228932882">"2 мин"</item>
-    <item msgid="7505084444184116101">"10 мин"</item>
-    <item msgid="4621683909972069205">"30 мин"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Очень медленная"</item>
     <item msgid="2361722960903353554">"Медленная"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Никогда, если есть питание от сети"</item>
     <item msgid="1986753720941888596">"Никогда"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Авто"</item>
+    <item msgid="6670588712989942178">"Только 5 ГГц"</item>
+    <item msgid="2715516524973207876">"Только 2,4 ГГц"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Время использования"</item>
     <item msgid="1908750532762193304">"Начать подсчет"</item>
diff --git a/res/values-ru/strings.xml b/res/values-ru/strings.xml
index 605f70a..afa95b5 100644
--- a/res/values-ru/strings.xml
+++ b/res/values-ru/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Выбор устройства Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Запрос разрешения на включение Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Приложение на вашем телефоне запрашивает разрешение на включение Bluetooth. Разрешить?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Приложение на вашем телефоне запрашивает разрешение на включение видимого режима Bluetooth на <xliff:g id="TIMEOUT">%1$d</xliff:g> с. Разрешить?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Приложение на вашем телефоне запрашивает разрешение на включение видимого режима Bluetooth на <xliff:g id="TIMEOUT">%1$d</xliff:g> с. Разрешить?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Приложение на вашем телефоне запрашивает разрешение на включение Bluetooth и видимого режима на <xliff:g id="TIMEOUT">%1$d</xliff:g> с. Разрешить?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Приложение на вашем телефоне запрашивает разрешение на включение Bluetooth и видимого режима на <xliff:g id="TIMEOUT">%1$d</xliff:g> с. Разрешить?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Включается Bluetooth..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"Настройки даты и времени"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Спящий режим"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"При каких условиях переключаться с Wi-Fi на сотовую сеть"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"При установке правила перехода в спящий режим возникла неполадка."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Полоса частот Wi-Fi"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Укажите рабочий диапазон частот"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"При настройке полосы частот возникла неполадка."</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MAC-адрес"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP-адрес"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"Настройки IP"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"Подключить SD-карту"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Очистить USB-накопитель"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"Очистить SD-карту"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Удаляет все данные с внутреннего USB-накопителя телефона, такие как музыка и фотографии"</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Удаляет с USB-накопителя музыку, фотографии и все другие данные."</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Удаляет все данные с внутреннего USB-накопителя телефона, такие как музыка и фотографии"</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"Недоступно"</string>
     <string name="read_only" msgid="6702420168629076340">" (только для чтения)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Сброс настроек"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Удаляет все данные из памяти телефона"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Удаляет все данные из памяти телефона"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Это приведет к удалению всех данных с "<b>"внутреннего накопителя"</b>" планшета, среди которых: "\n\n<li>"Ваш аккаунт Google;"</li>\n<li>"Настройки/данные системы и приложений;"</li>\n<li>"Загруженные приложения."</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Это приведет к удалению всех данных с "<b>"внутреннего накопителя"</b>", среди которых:"\n\n<li>"Ваш аккаунт Google;"</li>\n<li>"Настройки/данные системы и приложений;"</li>\n<li>"Загруженные приложения."</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"В настоящее время вы выполнили вход в следующие аккаунты:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Чтобы удалить музыку, изображения и другие пользовательские данные, необходимо удалить всю информацию с "<b>"USB-накопителя"</b>"."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Очистить USB-накопитель"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Очистить SD-карту"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Очищать внутренний накопитель."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Очищать внутренний накопитель."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Удалить с USB-накопителя музыку, фотографии и все другие данные."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Удаляет с SD-карты музыку, фотографии и все другие данные."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Сбросить настройки телефона"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Сбросить настройки телефона"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"Стереть всю личную информацию и загруженные приложения? Это действие нельзя отменить!"</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Начертить графический ключ"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Для подтверждения сброса настроек телефона необходимо начертить графический ключ."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"Не удалось выполнить сброс, поскольку служба System Clear недоступна."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Подтвердите операцию"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Очистить USB-накопитель"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"Очистить SD-карту"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Уничтожает все данные на USB-накопителе"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Использовать A-GPS"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"Использовать сервер для A-GPS (снимите флажок для менее интенсивного использования сети)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"Использовать сервер для A-GPS (снимите флажок для улучшения работы GPS)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"Мое местоположение"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Использовать данные о местоположении при поиске"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Использовать данные о местоположении в поиске и других службах Google"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"\"Мое местоположение\" используется для улучшения результатов поиска и работы других служб Google"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"О телефоне"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"О телефоне"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Посмотреть правовую информацию, состояние телефона, версию ПО"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Идет загрузка…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Сведения о безопасности"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Сведения о безопасности"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Телефон не подключен к службе передачи данных. Чтобы просмотреть эту информацию, откройте страницу %s на любом компьютере, подключенном к Интернету."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Идет загрузка…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Выберите пароль"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Выберите ПИН-код"</string>
diff --git a/res/values-sk/arrays.xml b/res/values-sk/arrays.xml
index 97425ea..537e254 100644
--- a/res/values-sk/arrays.xml
+++ b/res/values-sk/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Zobrazujú sa niektoré animácie okien"</item>
     <item msgid="488968798204105119">"Zobrazujú sa animácie okien"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 sekúnd"</item>
-    <item msgid="8881760709354815449">"30 sekúnd"</item>
-    <item msgid="7589406073232279088">"1 minúta"</item>
-    <item msgid="7001195990902244174">"2 min."</item>
-    <item msgid="5721688686241190620">"10 minút"</item>
-    <item msgid="7156442995039264948">"30 minút"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Veľmi pomalá"</item>
     <item msgid="2361722960903353554">"Pomalá"</item>
diff --git a/res/values-sk/strings.xml b/res/values-sk/strings.xml
index a7dbd6d..0f30dfc 100644
--- a/res/values-sk/strings.xml
+++ b/res/values-sk/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Výber zariadenia Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Žiadosť o povolenie zariadenia Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Aplikácia v telefóne vyžaduje povolenie na zapnutie pripojenia Bluetooth. Chcete udeliť toto povolenie?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Aplikácia v telefóne požaduje povolenie na nastavenie telefónu do viditeľného režimu pre ostatné zariadenia Bluetooth na <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Chcete udeliť toto povolenie?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Aplikácia v telefóne požaduje povolenie na nastavenie telefónu do viditeľného režimu pre ostatné zariadenia Bluetooth na <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Chcete udeliť toto povolenie?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Aplikácia v telefóne požaduje povolenie na zapnutie pripojenia Bluetooth a nastavenie telefónu do viditeľného režimu na <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Chcete udeliť toto povolenie?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Aplikácia v telefóne požaduje povolenie na zapnutie pripojenia Bluetooth a nastavenie telefónu do viditeľného režimu na <xliff:g id="TIMEOUT">%1$d</xliff:g> s. Chcete udeliť toto povolenie?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Prebieha zapínanie rozhrania Bluetooth..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"Nastavenia dátumu a času"</string>
@@ -863,7 +865,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Prebieha načítavanie…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Bezpečnostné informácie"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Bezpečnostné informácie"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Telefón nie je pripojený k dátovej službe. Ak chcete tieto informácie zobraziť teraz, prejdite v ľubovoľnom počítači pripojenom do siete Internet na adresu %s."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Prebieha načítavanie…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Zvoľte heslo"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Zvoľte kód PIN"</string>
@@ -1012,12 +1015,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Spustené aplikáciou: zastaviť dotykom"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-sl/arrays.xml b/res/values-sl/arrays.xml
index 3998c80..e84574b 100644
--- a/res/values-sl/arrays.xml
+++ b/res/values-sl/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Nekatere animacije oken so prikazane"</item>
     <item msgid="488968798204105119">"Prikazane so vse animacije oken"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 sekund"</item>
-    <item msgid="8881760709354815449">"30 sekund"</item>
-    <item msgid="7589406073232279088">"1 minuta"</item>
-    <item msgid="7001195990902244174">"2 minuti"</item>
-    <item msgid="5721688686241190620">"10 minut"</item>
-    <item msgid="7156442995039264948">"30 minut"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Zelo počasna"</item>
     <item msgid="2361722960903353554">"Počasna"</item>
diff --git a/res/values-sl/strings.xml b/res/values-sl/strings.xml
index ce94b1f..27df13b 100644
--- a/res/values-sl/strings.xml
+++ b/res/values-sl/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Izbirnik naprave Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Zahteva za dovoljenje za uporabo funkcije Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Eden od programov v telefonu zahteva dovoljenje, da vklopi Bluetooth. Ali želite to storiti?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Eden od programov v telefonu zahteva dovoljenje, da za <xliff:g id="TIMEOUT">%1$d</xliff:g> sekund omogoči vidnost telefona drugim napravam. Ali želite to storiti?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Eden od programov v telefonu zahteva dovoljenje, da za <xliff:g id="TIMEOUT">%1$d</xliff:g> sekund omogoči vidnost telefona drugim napravam. Ali želite to storiti?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Eden od programov v telefonu zahteva dovoljenje, da vklopi Bluetooth in za <xliff:g id="TIMEOUT">%1$d</xliff:g> sekund omogoči vidnost telefona drugim napravam. Ali želite to storiti?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Eden od programov v telefonu zahteva dovoljenje, da vklopi Bluetooth in za <xliff:g id="TIMEOUT">%1$d</xliff:g> sekund omogoči vidnost telefona drugim napravam. Ali želite to storiti?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Vklop Bluetootha …"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Datum in nastavitve"</string>
@@ -863,7 +865,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Nalaganje …"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informacije o varnosti"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informacije o varnosti"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Telefon ni povezan s podatkovno storitvijo. Če si želite podatke ogledati zdaj, obiščite %s s katerim koli računalnikom, ki je povezan z internetom."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Nalaganje …"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Izberite geslo"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Izberite kodo PIN"</string>
@@ -1012,12 +1015,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Zagon zaradi programa: ustavite z dotikom"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-sr/arrays.xml b/res/values-sr/arrays.xml
index 6aab778..0f08e41 100644
--- a/res/values-sr/arrays.xml
+++ b/res/values-sr/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Приказани су неки прозори са анимацијама"</item>
     <item msgid="488968798204105119">"Приказане су све анимације у прозору"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 секунди"</item>
-    <item msgid="8881760709354815449">"30 секунди"</item>
-    <item msgid="7589406073232279088">"1 минут"</item>
-    <item msgid="7001195990902244174">"2 минута"</item>
-    <item msgid="5721688686241190620">"10 минута"</item>
-    <item msgid="7156442995039264948">"30 минута"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Веома споро"</item>
     <item msgid="2361722960903353554">"Полако"</item>
diff --git a/res/values-sr/strings.xml b/res/values-sr/strings.xml
index 2796e26..43af5a9 100644
--- a/res/values-sr/strings.xml
+++ b/res/values-sr/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Bluetooth бирач уређаја"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Захтев за Bluetooth дозволу"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Апликација на телефону захтева дозволу да укључи Bluetooth. Желите ли ово да урадите?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Апликација на телефону захтева дозволу да учини ваш телефон видљивим за друге Bluetooth уређаје на <xliff:g id="TIMEOUT">%1$d</xliff:g> секунде(и). Желите ли ово да урадите?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Апликација на телефону захтева дозволу да учини ваш телефон видљивим за друге Bluetooth уређаје на <xliff:g id="TIMEOUT">%1$d</xliff:g> секунде(и). Желите ли ово да урадите?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Апликација на телефону захтева дозволу да укључи Bluetooth и да учини ваш телефон видљивим за друге уређаје на <xliff:g id="TIMEOUT">%1$d</xliff:g> секунде(и). Желите ли ово да урадите?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Апликација на телефону захтева дозволу да укључи Bluetooth и да учини ваш телефон видљивим за друге уређаје на <xliff:g id="TIMEOUT">%1$d</xliff:g> секунде(и). Желите ли ово да урадите?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Укључивање Bluetooth-а…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Подешавања датума и времена"</string>
@@ -863,7 +865,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Учитавање…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Безбедносне информације"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Безбедносне информације"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Телефон није повезан са услугом података. Да бисте одмах погледали ове информације, идите на %s са било ког рачунара повезаног са Интернетом."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Учитавање…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Одаберите лозинку"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Одаберите PIN"</string>
@@ -1012,12 +1015,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Покренула је апликација: додирните за заустављање"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-sv/arrays.xml b/res/values-sv/arrays.xml
index 42d877e..f3b2219 100644
--- a/res/values-sv/arrays.xml
+++ b/res/values-sv/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"Vissa fönsteranimeringar visas"</item>
     <item msgid="488968798204105119">"Alla fönsteranimeringar visas"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 sekunder"</item>
-    <item msgid="8881760709354815449">"30 sekunder"</item>
-    <item msgid="7589406073232279088">"1 minut"</item>
-    <item msgid="7001195990902244174">"2 minuter"</item>
-    <item msgid="5721688686241190620">"10 minuter"</item>
-    <item msgid="7156442995039264948">"30 minuter"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"omedelbart"</item>
-    <item msgid="6736512735606834431">"5 sekunder"</item>
-    <item msgid="8044619388267891375">"15 sekunder"</item>
-    <item msgid="1822002388249545488">"30 sekunder"</item>
-    <item msgid="8538071621211916519">"1 minut"</item>
-    <item msgid="5663439580228932882">"2 minuter"</item>
-    <item msgid="7505084444184116101">"10 minuter"</item>
-    <item msgid="4621683909972069205">"30 minuter"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Mycket långsam"</item>
     <item msgid="2361722960903353554">"Långsam"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Aldrig när den är inkopplad"</item>
     <item msgid="1986753720941888596">"Aldrig"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Automatiskt"</item>
+    <item msgid="6670588712989942178">"Endast 5 GHz"</item>
+    <item msgid="2715516524973207876">"Endast 2,4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Användningstid"</item>
     <item msgid="1908750532762193304">"Starta räkneverk"</item>
diff --git a/res/values-sv/strings.xml b/res/values-sv/strings.xml
index b793fdc..1055f5c 100644
--- a/res/values-sv/strings.xml
+++ b/res/values-sv/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Bluetooth-enhetsväljare"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Begäran om Bluetooth-behörighet"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Ett program i telefonen begär tillåtelse att aktivera Bluetooth. Vill du tillåta det?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Ett program i telefonen begär tillåtelse att göra telefonen synlig för andra Bluetooth-enheter i <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunder. Vill du tillåta det?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Ett program i telefonen begär tillåtelse att göra telefonen synlig för andra Bluetooth-enheter i <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunder. Vill du tillåta det?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Ett program i telefonen begär tillåtelse att aktivera Bluetooth och göra telefonen synlig för andra enheter i <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunder. Vill du tillåta det?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Ett program i telefonen begär tillåtelse att aktivera Bluetooth och göra telefonen synlig för andra enheter i <xliff:g id="TIMEOUT">%1$d</xliff:g> sekunder. Vill du tillåta det?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Aktiverar Bluetooth …"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Inställningar för datum och tid"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Wi-Fi-policy"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Ange när du vill växla från Wi-Fi till mobildata"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Ett problem inträffade när policy för viloläge skulle anges."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Wi-Fi-frekvensband"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Ange driftområde för frekvens"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Ett problem uppstod när frekvensband ställdes in."</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Mac-adress"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP-adress"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"IP-inställningar"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"Montera SD-kortet"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Radera USB-lagring"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"Radera SD-kort"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Raderar alla data på telefonens interna USB-lagring, som musik och foton."</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Raderar alla data på den interna USB-lagringsenheten, som musik och foton"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Raderar alla data på telefonens interna USB-lagring, som musik och foton."</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"Inte tillgängligt"</string>
     <string name="read_only" msgid="6702420168629076340">" (Skrivskyddad)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Återställ standardinst."</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Raderar alla data på telefonen"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Raderar alla data på telefonen"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Alla data på pekdatorns "<b>"interna lagring"</b>" raderas, inklusive:"\n\n<li>"ditt Google-konto"</li>\n<li>"system- och programdata och inställningar"</li>\n<li>"hämtade appar"</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Alla data på telefonens "<b>"interna lagring"</b>" raderas, inklusive:"\n\n<li>"ditt Google-konto"</li>\n<li>"system- och programdata och inställningar"</li>\n<li>"hämtade appar"</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Du är inloggad på följande konton:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Om du vill ta bort musik, bilder och andra användardata måste du radera "<b>"USB-lagringsenheten"</b>"."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Radera USB-lagring"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Radera SD-kort"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Radera alla data på telefonens interna USB-lagring, som musik och foton."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Radera alla data på telefonens interna USB-lagring, som musik och foton."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Radera alla data på den interna USB-lagringen, som musik och foton."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Radera alla data på SD-kortet, som musik och foton."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Återställ telefonen"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Återställ telefonen"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"Vill du ta bort all personlig information och alla hämtade program? Det går inte att ångra åtgärden!"</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Rita ditt grafiska lösenord"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Du måste rita ditt grafiska lösenord om du vill återställa telefonen."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"Återställningen utfördes inte eftersom tjänsten för systemrensning inte är tillgänglig."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Bekräfta återställning"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Radera USB-lagring"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"Radera SD-kort"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Raderar allt på USB-enheten"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Använd assisterad GPS"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"Använd servern för att förbättra GPS-funktionen (avmarkera om du vill minska nätverksbelastningen)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"Använd servern för att förbättra GPS-funktionen (avmarkera om du vill förbättra GPS-funktionen)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"Använd Min plats"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Använd plats för sökning på Google"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Använd plats för sökresultat och andra tjänster från Google"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"Plats används för att förbättra sökning och andra tjänster från Google"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"Om telefonen"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"Om telefonen"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Visa juridisk information, telefonstatus, programversion"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Läser in…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Säkerhetsinformation"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Säkerhetsinformation"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Din telefon är inte ansluten till en datatjänst. Besök %s på en dator som är ansluten till Internet om du vill visa informationen nu."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Läser in …"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Välj ett lösenord"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Välj en PIN-kod"</string>
diff --git a/res/values-th/arrays.xml b/res/values-th/arrays.xml
index 94ce4e4..a0f23c5 100644
--- a/res/values-th/arrays.xml
+++ b/res/values-th/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"แสดงภาพเคลื่อนไหวบนหน้าต่างบางภาพ"</item>
     <item msgid="488968798204105119">"แสดงภาพเคลื่อนไหวบนหน้าต่างทั้งหมด"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 วินาที"</item>
-    <item msgid="8881760709354815449">"30 วินาที"</item>
-    <item msgid="7589406073232279088">"1 นาที"</item>
-    <item msgid="7001195990902244174">"2 นาที"</item>
-    <item msgid="5721688686241190620">"10 นาที"</item>
-    <item msgid="7156442995039264948">"30 นาที"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"ช้ามาก"</item>
     <item msgid="2361722960903353554">"ช้า"</item>
diff --git a/res/values-th/strings.xml b/res/values-th/strings.xml
index e85e751..6e79049 100644
--- a/res/values-th/strings.xml
+++ b/res/values-th/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"ตัวเลือกอุปกรณ์บลูทูธ"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"คำขออนุญาตใช้บลูทูธ"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"แอปพลิเคชันบนโทรศัพท์คุณกำลังขออนุญาตเปิดบลูทูธ คุณต้องการทำตามนี้หรือไม่"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"แอปพลิเคชันบนโทรศัพท์ของคุณกำลังขออนุญาตเพื่อให้อุปกรณ์บลูทูธอื่นค้นพบโทรศัพท์ของคุณได้เป็นเวลา <xliff:g id="TIMEOUT">%1$d</xliff:g>  วินาที คุณต้องการทำตามนี้หรือไม่"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"แอปพลิเคชันบนโทรศัพท์ของคุณกำลังขออนุญาตเพื่อให้อุปกรณ์บลูทูธอื่นค้นพบโทรศัพท์ของคุณได้เป็นเวลา <xliff:g id="TIMEOUT">%1$d</xliff:g>  วินาที คุณต้องการทำตามนี้หรือไม่"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"แอปพลิเคชันบนโทรศัพท์ของคุณกำลังขออนุญาตเพื่อเปิดบลูทูธและให้อุปกรณ์อื่นค้นพบโทรศัพท์ของคุณได้เป็นเวลา <xliff:g id="TIMEOUT">%1$d</xliff:g> วินาที คุณต้องการทำตามนี้หรือไม่"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"แอปพลิเคชันบนโทรศัพท์ของคุณกำลังขออนุญาตเพื่อเปิดบลูทูธและให้อุปกรณ์อื่นค้นพบโทรศัพท์ของคุณได้เป็นเวลา <xliff:g id="TIMEOUT">%1$d</xliff:g> วินาที คุณต้องการทำตามนี้หรือไม่"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"กำลังเปิดบลูทูธ…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"การตั้งเวลาและวันที่"</string>
@@ -856,7 +858,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"กำลังโหลด…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"ข้อมูลความปลอดภัย"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"ข้อมูลความปลอดภัย"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"โทรศัพท์ของคุณไม่ได้เชื่อมต่อกับบริการข้อมูล หากต้องการดูข้อมูลนี้ในขณะนี้ ให้ไปที่ %s จากคอมพิวเตอร์ใดก็ได้ที่เชื่อมต่อกับอินเทอร์เน็ต"</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"กำลังโหลด…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"เลือกรหัสผ่านของคุณ"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"เลือก PIN ของคุณ"</string>
@@ -1005,12 +1008,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"เริ่มโดยแอปพลิเคชัน: แตะเพื่อหยุด"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-tl/arrays.xml b/res/values-tl/arrays.xml
index a604cfa..511b601 100644
--- a/res/values-tl/arrays.xml
+++ b/res/values-tl/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Ang ilang animation ng window ay ipinapakita"</item>
     <item msgid="488968798204105119">"Ipinakita ang lahat ng mga animation ng window"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 segundo"</item>
-    <item msgid="8881760709354815449">"30 segundo"</item>
-    <item msgid="7589406073232279088">"1 minuto"</item>
-    <item msgid="7001195990902244174">"2 minuto"</item>
-    <item msgid="5721688686241190620">"10 minuto"</item>
-    <item msgid="7156442995039264948">"30 minuto"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Napakabagal"</item>
     <item msgid="2361722960903353554">"Mabagal"</item>
diff --git a/res/values-tl/strings.xml b/res/values-tl/strings.xml
index a7202c6..9cb8798 100644
--- a/res/values-tl/strings.xml
+++ b/res/values-tl/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Tagapili ng device ng bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Kahilingan sa pahintulot ng bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Ang application sa iyong telepono ay humihiling ng pahintulot upang i-on ang Bluetooth. Gusto mong gawin ito?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Humihiling ang isang application sa iyong telepono ng pahintulot na gawing natutuklas ang iyong telepono ng ibang mga Bluetooth device sa loob ng <xliff:g id="TIMEOUT">%1$d</xliff:g> (na) segundo. Gusto mo ba itong gawin?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Humihiling ang isang application sa iyong telepono ng pahintulot na gawing natutuklas ang iyong telepono ng ibang mga Bluetooth device sa loob ng <xliff:g id="TIMEOUT">%1$d</xliff:g> (na) segundo. Gusto mo ba itong gawin?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Ang application na ito sa iyong telepono ay humihiling ng pahintulot upang i-on ang Bluetooth at upang magawang katuklas-tuklas ang iyong telepono ng ibang mga device para sa <xliff:g id="TIMEOUT">%1$d</xliff:g> (na) serbisyo. Gusto mong gawin ito?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Ang application na ito sa iyong telepono ay humihiling ng pahintulot upang i-on ang Bluetooth at upang magawang katuklas-tuklas ang iyong telepono ng ibang mga device para sa <xliff:g id="TIMEOUT">%1$d</xliff:g> (na) serbisyo. Gusto mong gawin ito?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Ino-on ang Bluetooth…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Mga setting ng petsa &amp; oras"</string>
@@ -865,7 +867,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Naglo-load…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Impormasyon sa kaligtasan"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Impormasyon sa kaligtasan"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Hindi nakakonekta ang iyong telepono sa serbisyo ng data. Upang matingnan ang impormasyon ngayon, pumunta sa %s mula sa anumang computer na nakakonekta sa Internet."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Naglo-load…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Piliin ang iyong password"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Piliin ang iyong PIN"</string>
@@ -1014,12 +1017,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Sinimulan ng application: galawin upang tumigil"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-tr/arrays.xml b/res/values-tr/arrays.xml
index 95c9b45..3ec1011 100644
--- a/res/values-tr/arrays.xml
+++ b/res/values-tr/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"Bazı pencere animasyonları gösterilir"</item>
     <item msgid="488968798204105119">"Tüm pencere animasyonları gösterilir"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 saniye"</item>
-    <item msgid="8881760709354815449">"30 saniye"</item>
-    <item msgid="7589406073232279088">"1 dakika"</item>
-    <item msgid="7001195990902244174">"2 dakika"</item>
-    <item msgid="5721688686241190620">"10 dakika"</item>
-    <item msgid="7156442995039264948">"30 dakika"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"derhal"</item>
-    <item msgid="6736512735606834431">"5 saniye"</item>
-    <item msgid="8044619388267891375">"15 saniye"</item>
-    <item msgid="1822002388249545488">"30 saniye"</item>
-    <item msgid="8538071621211916519">"1 dakika"</item>
-    <item msgid="5663439580228932882">"2 dakika"</item>
-    <item msgid="7505084444184116101">"10 dakika"</item>
-    <item msgid="4621683909972069205">"30 dakika"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Çok yavaş"</item>
     <item msgid="2361722960903353554">"Yavaş"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"Takılı olduğunda hiçbir zaman"</item>
     <item msgid="1986753720941888596">"Hiçbir zaman"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"Otomatik"</item>
+    <item msgid="6670588712989942178">"Yalnızca 5 GHz"</item>
+    <item msgid="2715516524973207876">"Yalnızca 2,4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"Kullanım Süresi"</item>
     <item msgid="1908750532762193304">"Sayımı Başlat"</item>
diff --git a/res/values-tr/strings.xml b/res/values-tr/strings.xml
index 1313ee9..c909e14 100644
--- a/res/values-tr/strings.xml
+++ b/res/values-tr/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Bluetooth cihazı seçicisi"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Bluetooth izin isteği"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Telefonunuzdaki bir uygulama, Bluetooth\'u açmak için izin istiyor. Bunu yapmak istiyor musunuz?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Telefonunuzdaki bir uygulama telefonunuzu <xliff:g id="TIMEOUT">%1$d</xliff:g> saniye boyunca diğer Bluetooth cihazları tarafından bulunabilir duruma getirmek için izin istiyor. Bunu yapmak istiyor musunuz?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Telefonunuzdaki bir uygulama telefonunuzu <xliff:g id="TIMEOUT">%1$d</xliff:g> saniye boyunca diğer Bluetooth cihazları tarafından bulunabilir duruma getirmek için izin istiyor. Bunu yapmak istiyor musunuz?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Telefonunuzdaki bir uygulama, <xliff:g id="TIMEOUT">%1$d</xliff:g> saniye boyunca Bluetooth\'u açmak ve telefonunuzu diğer cihazlar tarafından bulunabilir duruma getirmek için izin istiyor. Bunu yapmak istiyor musunuz?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Telefonunuzdaki bir uygulama, <xliff:g id="TIMEOUT">%1$d</xliff:g> saniye boyunca Bluetooth\'u açmak ve telefonunuzu diğer cihazlar tarafından bulunabilir duruma getirmek için izin istiyor. Bunu yapmak istiyor musunuz?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Bluetooth açılıyor..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"Tarih ve saat ayarları"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Kablosuz uyku politikası"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"Kablosuzdan mobil veriye geçme zamanını belirt"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"Uyku politikası ayarlanırken bir sorun oluştu."</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Kablosuz frekans bandı"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"İşlemin sıklık aralığını belirtin"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Frekans bandı ayarlanırken bir sorun oldu."</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MAC adresi"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP adresi"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"IP ayarları"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"SD kartı ekle"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"USB depolama birimini sil"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"SD kartı sil"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Telefonunun USB depolama birimindeki müzik ve foto gibi tüm veriler silinir."</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Dahili USB depolama birimindeki müzik ve fotoğraf gibi tüm verileri siler"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"Telefonunun USB depolama birimindeki müzik ve foto gibi tüm veriler silinir."</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"Kullanılamıyor"</string>
     <string name="read_only" msgid="6702420168629076340">" (Salt okunur)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"Fabrika verilerine sıfırla"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Telefondaki tüm verileri siler"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Telefondaki tüm verileri siler"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"Bu işlem tablet bilgisayarınızın "<b>"dahili depolama alanından"</b>" şu verilerin tümünü siler:"\n\n<li>"Google hesabınız"</li>\n<li>"Sistem ve uygulama verileri ile ayarları"</li>\n<li>"İndirilen uygulamalar"</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"Bu işlem telefonunuzun "<b>"dahili depolama alanından"</b>" şu verilerini tümünü siler:"\n\n<li>"Google hesabınız"</li>\n<li>"Sistem ve uygulama verileri ve ayarları"</li>\n<li>"İndirilen uygulamalar"</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Şu anda aşağıdaki hesaplarda oturum açmış durumdasınız:"\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"Müzik, resimler ve diğer kullanıcı verilerinin de temizlenmesi için "<b>"USB depolama biriminin"</b>" silinmesi gerekir."</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"USB depolama birimini sil"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"SD kartı sil"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Telefonunun USB depolama birimindeki müzik veya foto gibi tüm veriler silinir."</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"Telefonunun USB depolama birimindeki müzik veya foto gibi tüm veriler silinir."</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"Dahili USB depolama birimindeki müzik veya fotoğraf gibi tüm veriler silinir."</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"SD kartındaki müzik ve fotoğraf gibi tüm veriler silinir."</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Telefonu sıfırla"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Telefonu sıfırla"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"Tüm kişisel bilgilerinizi ve indirilen tüm uygulamaları silmek istiyor musunuz? Bu işlem geri döndürülemez!"</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Kilit açma deseninizi çizin"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"Telefon sıfırlamayı onaylamak için kilit açma deseninizi çizmelisiniz."</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"Sistem Temizleme hizmeti kullanılamadığından sıfırlama yapılmadı."</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"Sıfırlamayı onayla"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"USB depolama birimini sil"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"SD kartı sil"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"USB dep brmdki tüm verlr siler"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"Desteklenen GPS kullan"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"GPS\'ye destek olmak için sunucu kullan (ağ kullanımını azaltmak için onay işaretini kaldırın)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"GPS\'ye yardımcı olmak için sunucu kullan (GPS performansını iyileştirmek için onay işaretini kaldırın)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"Konumum\'u Kullan"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"Google arama için konum kullan"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"Google arama ve diğer Google hizmetleri için konum kullan"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"Google arama sonuçları ve diğer Google hizmetlerini iyileştirmek için kullanılan konum"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"Telefon hakkında"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"Telefon hakkında"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"Yasal bilgileri, telefon durumunu, yazılım sürümünü görüntüle"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Yükleniyor…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Güvenlik bilgileri"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Güvenlik bilgileri"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Telefonunuz bir veri hizmetine bağlı değil. Bu bilgiyi şimdi görüntülemek için İnternet\'e bağlı herhangi bir bilgisayardan %s adresine gidin."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Yükleniyor…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Şifrenizi seçin"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"PIN\'inizi seçin"</string>
diff --git a/res/values-uk/arrays.xml b/res/values-uk/arrays.xml
index d9ff71c..0b5a1e5 100644
--- a/res/values-uk/arrays.xml
+++ b/res/values-uk/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Відображено деякі анімації вікон"</item>
     <item msgid="488968798204105119">"Відображаюся всі анімації вікна"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 секунд"</item>
-    <item msgid="8881760709354815449">"30 секунд"</item>
-    <item msgid="7589406073232279088">"1 хвилина"</item>
-    <item msgid="7001195990902244174">"2 хв."</item>
-    <item msgid="5721688686241190620">"10 хв."</item>
-    <item msgid="7156442995039264948">"30 хв."</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Дуже пов."</item>
     <item msgid="2361722960903353554">"Повіл."</item>
diff --git a/res/values-uk/strings.xml b/res/values-uk/strings.xml
index 429cf45..e1168ce 100644
--- a/res/values-uk/strings.xml
+++ b/res/values-uk/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Інстр.виб.пристр.Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Запит на дозвіл Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Програма у вашому телефоні просить дозволу на ввімкнення Bluetooth. Зробити це?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Програма у вашому телефоні просить дозволу на надання телефону видимості іншими пристроями Bluetooth протягом <xliff:g id="TIMEOUT">%1$d</xliff:g> сек. Зробити це?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Програма у вашому телефоні просить дозволу на надання телефону видимості іншими пристроями Bluetooth протягом <xliff:g id="TIMEOUT">%1$d</xliff:g> сек. Зробити це?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Програма у вашому телефоні просить дозволу на ввімкнення Bluetooth та надання телефону видимості іншими пристроями протягом <xliff:g id="TIMEOUT">%1$d</xliff:g> сек. Зробити це?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Програма у вашому телефоні просить дозволу на ввімкнення Bluetooth та надання телефону видимості іншими пристроями протягом <xliff:g id="TIMEOUT">%1$d</xliff:g> сек. Зробити це?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Увімкнення Bluetooth…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Налаштування дати та часу"</string>
@@ -863,7 +865,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Завант-ня…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Інф-я про безпеку"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Інф-я про безпеку"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Ваш тел. не підключ. до служби даних. Щоб переглянути цю інф-ю зараз, перейдіть до %s з будь-якого комп\'ютера, підключ. до Інтернету."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Завантаж…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Виберіть пароль"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Виберіть свій PIN"</string>
@@ -1012,12 +1015,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Запущено програмою: натисн., щоб зупин."</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-vi/arrays.xml b/res/values-vi/arrays.xml
index 2c45c6d..02f896b 100644
--- a/res/values-vi/arrays.xml
+++ b/res/values-vi/arrays.xml
@@ -39,22 +39,16 @@
     <item msgid="4460915688877708508">"Một số hoạt ảnh trên cửa sổ được hiển thị"</item>
     <item msgid="488968798204105119">"Tất cả hoạt ảnh trên cửa sổ được hiển thị"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 giây"</item>
-    <item msgid="8881760709354815449">"30 giây"</item>
-    <item msgid="7589406073232279088">"1 phút"</item>
-    <item msgid="7001195990902244174">"2 phút"</item>
-    <item msgid="5721688686241190620">"10 phút"</item>
-    <item msgid="7156442995039264948">"30 phút"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
     <!-- no translation found for lock_after_timeout_entries:0 (5416834369150305288) -->
     <!-- no translation found for lock_after_timeout_entries:1 (6736512735606834431) -->
     <!-- no translation found for lock_after_timeout_entries:2 (8044619388267891375) -->
     <!-- no translation found for lock_after_timeout_entries:3 (1822002388249545488) -->
     <!-- no translation found for lock_after_timeout_entries:4 (8538071621211916519) -->
     <!-- no translation found for lock_after_timeout_entries:5 (5663439580228932882) -->
-    <!-- no translation found for lock_after_timeout_entries:6 (7505084444184116101) -->
-    <!-- no translation found for lock_after_timeout_entries:7 (4621683909972069205) -->
+    <!-- no translation found for lock_after_timeout_entries:6 (49888496216106852) -->
+    <!-- no translation found for lock_after_timeout_entries:7 (9002737361305019353) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"Rất chậm"</item>
     <item msgid="2361722960903353554">"Chậm"</item>
diff --git a/res/values-vi/strings.xml b/res/values-vi/strings.xml
index 27f2659..6db37b0 100644
--- a/res/values-vi/strings.xml
+++ b/res/values-vi/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"Trình chọn thiết bị Bluetooth"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"Yêu cầu quyền Bluetooth"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"Ứng dụng trên điện thoại của bạn đang yêu cầu quyền bật Bluetooth. Bạn có muốn thực hiện thao tác này không?"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"Ứng dụng trên điện thoại của bạn đang yêu cầu quyền đặt điện thoại của bạn ở chế độ có thể phát hiện bởi các thiết bị Bluetooth khác trong <xliff:g id="TIMEOUT">%1$d</xliff:g> giây. Bạn có muốn thực hiện thao tác này không?"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"Ứng dụng trên điện thoại của bạn đang yêu cầu quyền đặt điện thoại của bạn ở chế độ có thể phát hiện bởi các thiết bị Bluetooth khác trong <xliff:g id="TIMEOUT">%1$d</xliff:g> giây. Bạn có muốn thực hiện thao tác này không?"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"Ứng dụng trên điện thoại của bạn đang yêu cầu quyền bật Bluetooth và đặt điện thoại của bạn ở chế độ có thể phát hiện bởi các thiết bị khác trong <xliff:g id="TIMEOUT">%1$d</xliff:g> giây. Bạn có muốn thực hiện thao tác này không?"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"Ứng dụng trên điện thoại của bạn đang yêu cầu quyền bật Bluetooth và đặt điện thoại của bạn ở chế độ có thể phát hiện bởi các thiết bị khác trong <xliff:g id="TIMEOUT">%1$d</xliff:g> giây. Bạn có muốn thực hiện thao tác này không?"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"Đang bật Bluetooth…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"Cài đặt ngày &amp; giờ"</string>
@@ -865,7 +867,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"Đang tải…"</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"Thông tin an toàn"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Thông tin an toàn"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"Điện thoại của bạn chưa được kết nối với dịch vụ dữ liệu. Để xem thông tin này ngay bây giờ, hãy truy cập %s từ bất kỳ máy tính nào đã kết nối Internet."</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Đang tải…"</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Chọn mật khẩu của bạn"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Chọn mã PIN của bạn"</string>
@@ -1014,12 +1017,8 @@
     <!-- outdated translation 8432097226392386802 -->     <string name="service_started_by_app" msgid="6575184738671598131">"Được bắt đầu bằng ứng dụng: chạm để dừng"</string>
     <!-- no translation found for service_client_name (4037193625611815517) -->
     <skip />
-    <!-- unknown placeholder FREE in service_background_processes -->
-    <skip />
     <!-- no translation found for service_background_processes (6844156253576174488) -->
     <skip />
-    <!-- unknown placeholder COUNT in service_foreground_processes -->
-    <skip />
     <!-- no translation found for service_foreground_processes (7583975676795574276) -->
     <skip />
     <!-- no translation found for memory (6609961111091483458) -->
diff --git a/res/values-zh-rCN/arrays.xml b/res/values-zh-rCN/arrays.xml
index 079ebac..01af948 100644
--- a/res/values-zh-rCN/arrays.xml
+++ b/res/values-zh-rCN/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"显示部分窗口动画"</item>
     <item msgid="488968798204105119">"显示所有窗口动画"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 秒"</item>
-    <item msgid="8881760709354815449">"30 秒"</item>
-    <item msgid="7589406073232279088">"1 分钟"</item>
-    <item msgid="7001195990902244174">"2 分钟"</item>
-    <item msgid="5721688686241190620">"10 分钟"</item>
-    <item msgid="7156442995039264948">"30 分钟"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"无延迟"</item>
-    <item msgid="6736512735606834431">"5 秒"</item>
-    <item msgid="8044619388267891375">"15 秒"</item>
-    <item msgid="1822002388249545488">"30 秒"</item>
-    <item msgid="8538071621211916519">"1 分钟"</item>
-    <item msgid="5663439580228932882">"2 分钟"</item>
-    <item msgid="7505084444184116101">"10 分钟"</item>
-    <item msgid="4621683909972069205">"30 分钟"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"很慢"</item>
     <item msgid="2361722960903353554">"慢"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"充电时永不休眠"</item>
     <item msgid="1986753720941888596">"永不休眠"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"自动"</item>
+    <item msgid="6670588712989942178">"仅使用 5 GHz 频带"</item>
+    <item msgid="2715516524973207876">"仅使用 2.4 GHz 频带"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"使用时间"</item>
     <item msgid="1908750532762193304">"启动次数"</item>
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index 86c4ae6..094ef25 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"蓝牙设备选择器"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"蓝牙权限请求"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"您手机上的某一应用程序正在请求相应权限以便打开蓝牙。是否要授予这种权限？"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"您手机上的某一应用程序正在请求相应权限以便打开蓝牙，从而使其他设备可在 <xliff:g id="TIMEOUT">%1$d</xliff:g> 秒内检测到您的手机。是否要授予这种权限？"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"您手机上的某一应用程序正在请求相应权限以便打开蓝牙，从而使其他设备可在 <xliff:g id="TIMEOUT">%1$d</xliff:g> 秒内检测到您的手机。是否要授予这种权限？"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"您手机上的某一应用程序正在请求相应权限以便打开蓝牙，从而使其他设备可在 <xliff:g id="TIMEOUT">%1$d</xliff:g> 秒内检测到您的手机。是否要授予这种权限？"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"您手机上的某一应用程序正在请求相应权限以便打开蓝牙，从而使其他设备可在 <xliff:g id="TIMEOUT">%1$d</xliff:g> 秒内检测到您的手机。是否要授予这种权限？"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"正在打开蓝牙…"</string>
     <string name="date_and_time" msgid="4114084177056654663">"日期和时间设置"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Wi-Fi 休眠策略"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"指定何时要从 Wi-Fi 切换到手机数据"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"设置休眠策略时出现问题。"</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Wi-Fi 频带"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"指定操作的频率范围"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"设置频带时出现问题。"</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MAC 地址"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP 地址"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"IP 设置"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"安装 SD 卡"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"格式化 USB 存储设备"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"格式化 SD 卡"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"清除手机的内部 USB 存储设备中的全部数据，例如音乐和照片"</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"清除内部 USB 存储设备中的全部数据，例如音乐和照片"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"清除手机的内部 USB 存储设备中的全部数据，例如音乐和照片"</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"不可用"</string>
     <string name="read_only" msgid="6702420168629076340">" （只读）"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"恢复出厂设置"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"清除手机上的所有数据"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"清除手机上的所有数据"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"此操作会清除您手机的"<b>"内部存储设备"</b>"中的全部数据，包括："\n\n<li>"您的 Google 帐户"</li>\n<li>"系统和应用程序数据和设置"</li>\n<li>"已下载的应用程序"</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"此操作会清除您手机的"<b>"内部存储设备"</b>"中的全部数据，包括："\n\n<li>"您的 Google 帐户"</li>\n<li>"系统和应用程序数据和设置"</li>\n<li>"已下载的应用程序"</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"目前，您已登录以下帐户："\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"要清除音乐、照片和其他用户数据，请格式化 "<b>"USB 存储设备"</b>"。"</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"格式化 USB 存储设备"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"格式化 SD 卡"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"清除手机的内部 USB 存储设备中的全部数据，例如音乐或照片。"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"清除手机的内部 USB 存储设备中的全部数据，例如音乐或照片。"</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"清除内部 USB 存储设备中的全部数据，例如音乐或照片。"</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"清除 SD 卡中的全部数据，例如音乐或照片。"</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"重置手机"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"重置手机"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"是否删除所有个人信息和下载的所有应用程序？此操作无法还原！"</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"绘制您的解锁图案"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"您必须绘制解锁图案才能确认重置手机。"</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"未执行重置，因为系统清除服务不可用。"</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"确认重置"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"格式化 USB 存储设备"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"格式化 SD 卡"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"清除 USB 存储设备中的全部数据"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"使用增强型 GPS"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"使用服务器来辅助 GPS（取消选中可降低网络使用率）"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"使用服务器来辅助 GPS（取消选中可提高 GPS 性能）"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"使用“我的位置”"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"将位置用于 Google 搜索"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"将位置用于 Google 搜索和 Google 的其他服务"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"已将位置用于改进 Google 搜索结果和 Google 的其他服务"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"关于手机"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"关于手机"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"查看法律信息、手机状态和软件版本"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"正在载入..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"安全信息"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"安全信息"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"您的手机未连接到数据服务。要立即查看此信息，请通过连接到互联网的任意计算机访问 %s。"</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"正在载入..."</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"选择您的密码"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"选择您的 PIN"</string>
diff --git a/res/values-zh-rTW/arrays.xml b/res/values-zh-rTW/arrays.xml
index b381706..b8d757a 100644
--- a/res/values-zh-rTW/arrays.xml
+++ b/res/values-zh-rTW/arrays.xml
@@ -39,24 +39,8 @@
     <item msgid="4460915688877708508">"顯示部分視窗動畫"</item>
     <item msgid="488968798204105119">"顯示所有視窗動畫"</item>
   </string-array>
-  <string-array name="screen_timeout_entries">
-    <item msgid="3342301044271143016">"15 秒"</item>
-    <item msgid="8881760709354815449">"30 秒"</item>
-    <item msgid="7589406073232279088">"1 分鐘"</item>
-    <item msgid="7001195990902244174">"2 分鐘"</item>
-    <item msgid="5721688686241190620">"10 分鐘"</item>
-    <item msgid="7156442995039264948">"30 分鐘"</item>
-  </string-array>
-  <string-array name="lock_after_timeout_entries">
-    <item msgid="5416834369150305288">"立即"</item>
-    <item msgid="6736512735606834431">"5 秒"</item>
-    <item msgid="8044619388267891375">"15 秒"</item>
-    <item msgid="1822002388249545488">"30 秒"</item>
-    <item msgid="8538071621211916519">"1 分鐘"</item>
-    <item msgid="5663439580228932882">"2 分鐘"</item>
-    <item msgid="7505084444184116101">"10 分鐘"</item>
-    <item msgid="4621683909972069205">"30 分鐘"</item>
-  </string-array>
+    <!-- no translation found for screen_timeout_entries:6 (6864027152847611413) -->
+    <!-- no translation found for lock_after_timeout_entries:8 (4322676235684793329) -->
   <string-array name="tts_rate_entries">
     <item msgid="6041212618892492920">"非常慢"</item>
     <item msgid="2361722960903353554">"慢"</item>
@@ -125,9 +109,11 @@
     <item msgid="1549288661423279207">"插入時絕不"</item>
     <item msgid="1986753720941888596">"永不"</item>
   </string-array>
-    <!-- no translation found for wifi_frequency_band_entries:0 (624340809384223320) -->
-    <!-- no translation found for wifi_frequency_band_entries:1 (6670588712989942178) -->
-    <!-- no translation found for wifi_frequency_band_entries:2 (2715516524973207876) -->
+  <string-array name="wifi_frequency_band_entries">
+    <item msgid="624340809384223320">"自動"</item>
+    <item msgid="6670588712989942178">"僅限 5 GHz"</item>
+    <item msgid="2715516524973207876">"僅限 2.4 GHz"</item>
+  </string-array>
   <string-array name="usage_stats_display_order_types">
     <item msgid="9077371706468756228">"使用時間"</item>
     <item msgid="1908750532762193304">"啟動計數"</item>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index f689794..3744be4 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -116,9 +116,11 @@
     <string name="device_picker" msgid="8721012448931226323">"藍牙裝置選取器"</string>
     <string name="bluetooth_permission_request" msgid="1523129741266262748">"藍牙權限要求"</string>
     <!-- outdated translation 2342558978033892004 -->     <string name="bluetooth_ask_enablement" msgid="8211158472876087588">"手機上的某個應用程式要求開啟藍牙裝置，您想要允許要求嗎？"</string>
-    <!-- outdated translation 669870705606180872 -->     <string name="bluetooth_ask_discovery" product="tablet" msgid="5950965604673262829">"手機上的某個應用程式要求開啟藍牙裝置，這表示您的藍牙連線將開放 <xliff:g id="TIMEOUT">%1$d</xliff:g> 秒，讓其他裝置可在時間內搜尋到您的手機。您想要允許要求嗎？"</string>
+    <!-- no translation found for bluetooth_ask_discovery (5950965604673262829) -->
+    <skip />
     <string name="bluetooth_ask_discovery" product="default" msgid="669870705606180872">"手機上的某個應用程式要求開啟藍牙裝置，這表示您的藍牙連線將開放 <xliff:g id="TIMEOUT">%1$d</xliff:g> 秒，讓其他裝置可在時間內搜尋到您的手機。您想要允許要求嗎？"</string>
-    <!-- outdated translation 7220210326619399542 -->     <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="5716077575971497298">"手機上的某個應用程式要求開啟藍牙裝置，這表示您的藍牙連線將開放 <xliff:g id="TIMEOUT">%1$d</xliff:g> 秒，讓其他裝置可在時間內搜尋到您的手機。您想要允許要求嗎？"</string>
+    <!-- no translation found for bluetooth_ask_enablement_and_discovery (5716077575971497298) -->
+    <skip />
     <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="7220210326619399542">"手機上的某個應用程式要求開啟藍牙裝置，這表示您的藍牙連線將開放 <xliff:g id="TIMEOUT">%1$d</xliff:g> 秒，讓其他裝置可在時間內搜尋到您的手機。您想要允許要求嗎？"</string>
     <string name="bluetooth_turning_on" msgid="3107102168379705771">"正在開啟藍牙..."</string>
     <string name="date_and_time" msgid="4114084177056654663">"日期與時間設定"</string>
@@ -461,12 +463,9 @@
     <string name="wifi_setting_sleep_policy_title" msgid="1367731352485585528">"Wi-Fi 休眠設定"</string>
     <string name="wifi_setting_sleep_policy_summary" msgid="7573693311804602041">"指定何時要從 Wi-Fi 切換到行動數據"</string>
     <string name="wifi_setting_sleep_policy_error" msgid="5103670439972135148">"休眠設定時發生問題。"</string>
-    <!-- no translation found for wifi_setting_frequency_band_title (7493768705046080060) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_summary (3250740757118009784) -->
-    <skip />
-    <!-- no translation found for wifi_setting_frequency_band_error (837281974489794378) -->
-    <skip />
+    <string name="wifi_setting_frequency_band_title" msgid="7493768705046080060">"Wi-Fi 頻帶"</string>
+    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"指定作業的頻率範圍"</string>
+    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"設定頻帶時發生問題。"</string>
     <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MAC 位址"</string>
     <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP 位址"</string>
     <string name="wifi_ip_settings_titlebar" msgid="4345739031248760326">"IP 設定"</string>
@@ -639,7 +638,7 @@
     <string name="sd_mount_summary" product="default" msgid="4936591681679097699">"掛載 SD 卡"</string>
     <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"清除 USB 儲存裝置"</string>
     <string name="sd_format" product="default" msgid="2576054280507119870">"清除 SD 卡"</string>
-    <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"清除手機內部 USB 儲存裝置的所有資料，例如音樂和相片。"</string>
+    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"清除內部 USB 儲存裝置中的所有資料，例如音樂和相片"</string>
     <!-- outdated translation 1504606546865152514 -->     <string name="sd_format_summary" product="default" msgid="212703692181793109">"清除手機內部 USB 儲存裝置的所有資料，例如音樂和相片。"</string>
     <string name="sd_unavailable" msgid="8580107589533213904">"無法取得資訊"</string>
     <string name="read_only" msgid="6702420168629076340">" (唯讀)"</string>
@@ -693,24 +692,16 @@
     <string name="master_clear_title" msgid="5907939616087039756">"重設為原廠設定"</string>
     <!-- outdated translation 4986154238001088492 -->     <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"清除手機上所有資料"</string>
     <string name="master_clear_summary" product="default" msgid="4986154238001088492">"清除手機上所有資料"</string>
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (1305457209008369655) -->
-    <skip />
-    <!-- unknown placeholder TAG_B_0 in master_clear_desc -->
-    <skip />
-    <!-- no translation found for master_clear_desc (2950536633526374209) -->
-    <skip />
-    <!-- no translation found for master_clear_accounts (6412857499147999073) -->
-    <skip />
-    <!-- no translation found for master_clear_desc_erase_external_storage (4740866328425123395) -->
-    <skip />
+    <string name="master_clear_desc" product="tablet" msgid="1305457209008369655">"這會清除您平板電腦"<b>"內部儲存裝置"</b>"中的所有資料，包含："\n\n<li>"您的 Google 帳戶"</li>\n<li>"系統和應用程式資料及設定"</li>\n<li>"已下載的應用程式"</li></string>
+    <string name="master_clear_desc" product="default" msgid="2950536633526374209">"這會清除您手機"<b>"內部儲存裝置"</b>"中的所有資料，包含："\n\n<li>"您的 Google 帳戶"</li>\n<li>"系統和應用程式資料及設定"</li>\n<li>"已下載的應用程式"</li></string>
+    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"您目前已登入下列帳戶："\n</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="4740866328425123395">\n\n"如要一併清除音樂、圖片及其他使用者資料，則需清除 "<b>"USB 儲存裝置"</b>"。"</string>
     <!-- no translation found for master_clear_desc_erase_external_storage (7339100478676372901) -->
     <skip />
     <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"清除 USB 儲存裝置"</string>
     <string name="erase_external_storage" product="default" msgid="1397239046334307625">"清除 SD 卡"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"清除手機內部 USB 儲存裝置的所有資料，例如音樂或相片。"</string>
-    <!-- outdated translation 1657838142707381027 -->     <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"清除手機內部 USB 儲存裝置的所有資料，例如音樂或相片。"</string>
+    <string name="erase_external_storage_description" product="nosdcard" msgid="444834593696342279">"清除內部 USB 儲存裝置中的所有資料，例如音樂或相片。"</string>
+    <string name="erase_external_storage_description" product="default" msgid="46603515218075174">"清除 SD 卡中的所有資料，例如音樂或相片。"</string>
     <!-- outdated translation 7550632653343157971 -->     <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"重設手機"</string>
     <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"重設手機"</string>
     <string name="master_clear_final_desc" msgid="6917971132484622696">"要清除所有個人資料及先前下載的應用程式嗎？這個動作無法復原！"</string>
@@ -718,8 +709,7 @@
     <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"畫出解鎖圖形"</string>
     <!-- outdated translation 8901714274312707918 -->     <string name="master_clear_gesture_explanation" msgid="2234954758550554549">"請畫出解鎖圖形，以確認重設手機。"</string>
     <string name="master_clear_failed" msgid="8655202125010189406">"因「系統清除」服務異常，未成功執行重設。"</string>
-    <!-- no translation found for master_clear_confirm_title (4845794266129586839) -->
-    <skip />
+    <string name="master_clear_confirm_title" msgid="4845794266129586839">"確認重設"</string>
     <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"清除 USB 儲存裝置"</string>
     <string name="media_format_title" product="default" msgid="4427528440306787972">"清除 SD 卡"</string>
     <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"清除 USB 儲存裝置中的所有資料"</string>
@@ -782,11 +772,9 @@
     <string name="assisted_gps" msgid="4649317129586736885">"使用輔助 GPS"</string>
     <string name="assisted_gps_enabled" msgid="8751899609589792803">"使用伺服器輔助 GPS (取消勾選即可降低網路使用量)"</string>
     <string name="assisted_gps_disabled" msgid="6982698333968010748">"使用伺服器輔助 GPS (取消勾選即可提升 GPS 效能)"</string>
-    <!-- outdated translation 5447030582538504247 -->     <string name="use_location_title" msgid="3214740644957841179">"使用我的位置"</string>
-    <!-- no translation found for use_location_summary_disabled (1876901471649359806) -->
-    <skip />
-    <!-- no translation found for use_location_summary_enabled (984549156918597265) -->
-    <skip />
+    <string name="use_location_title" msgid="3214740644957841179">"將位置資訊用於 Google 搜尋"</string>
+    <string name="use_location_summary_disabled" msgid="1876901471649359806">"將位置資訊用於 Google 搜尋和其他 Google 服務"</string>
+    <string name="use_location_summary_enabled" msgid="984549156918597265">"系統已採用位置資訊來改善 Google 搜尋結果和其他 Google 服務"</string>
     <!-- outdated translation 1743378368185371685 -->     <string name="about_settings" product="tablet" msgid="593457295516533765">"關於手機"</string>
     <string name="about_settings" product="default" msgid="1743378368185371685">"關於手機"</string>
     <!-- outdated translation 3302263393543848667 -->     <string name="about_settings_summary" msgid="3371517697156165959">"檢視法律資訊、手機狀態、軟體版本"</string>
@@ -803,7 +791,8 @@
     <string name="settings_license_activity_loading" msgid="3337535809093591740">"載入中..."</string>
     <string name="settings_safetylegal_title" msgid="1289483965535937431">"安全資訊"</string>
     <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"安全資訊"</string>
-    <!-- outdated translation 3198912875259612887 -->     <string name="settings_safetylegal_activity_unreachable" msgid="170670055116721810">"您的手機尚未與資料傳輸服務連線。如要檢視此資訊，請使用任何可上網的電腦前往 %s。"</string>
+    <!-- no translation found for settings_safetylegal_activity_unreachable (170670055116721810) -->
+    <skip />
     <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"載入中..."</string>
     <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"選擇密碼"</string>
     <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"選擇您的 PIN"</string>
