diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index 0328dc9..02b902e 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -54,7 +54,7 @@
     <string name="stop" msgid="5687251076030630074">"Zastavit"</string>
     <string name="reload" msgid="8585220783228408062">"Aktualizovat"</string>
     <string name="back" msgid="8414603107175713668">"Zpět"</string>
-    <string name="forward" msgid="4288210890526641577">"Předat dál"</string>
+    <string name="forward" msgid="4288210890526641577">"Vpřed"</string>
     <string name="save" msgid="5922311934992468496">"OK"</string>
     <string name="do_not_save" msgid="6777633870113477714">"Zrušit"</string>
     <string name="location" msgid="3411848697912600125">"Adresa"</string>
@@ -186,7 +186,7 @@
     <string name="autofill_setup_dialog_message" msgid="7123905786076456503">"Podobné webové formuláře může prohlížeč vyplňovat automaticky. Chcete nastavit automatické vyplňování textu?"</string>
     <string name="autofill_setup_dialog_negative_toast" msgid="3288881675232206984">"Automatické vyplňování můžete kdykoliv nastavit na obrazovce Prohlížeč &gt; Nastavení &gt; Obecné."</string>
     <string name="disable_autofill" msgid="8305901059849400354">"Vypnout automatické vyplňování"</string>
-    <string name="pref_privacy_security_title" msgid="3480313968942160914">"Ochrana osobních údajů a zabezpečení"</string>
+    <string name="pref_privacy_security_title" msgid="3480313968942160914">"Ochrana soukromí a zabezpečení"</string>
     <string name="pref_privacy_clear_cache" msgid="3380316479925886998">"Vymazat mezipaměť"</string>
     <string name="pref_privacy_clear_cache_summary" msgid="2216463577207991454">"Vymazat všechen obsah a databáze uložené do místní mezipaměti"</string>
     <string name="pref_privacy_clear_cache_dlg" msgid="4344512581716422465">"Vymazat všechen obsah a databáze uložené v místní mezipaměti?"</string>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index a0dd74e..9633cd2 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -216,7 +216,7 @@
     <string name="pref_security_save_form_data" msgid="1213669802810198893">"Recordar formularios"</string>
     <string name="pref_security_save_form_data_summary" msgid="4994074685153708026">"Recordar datos introducidos en formularios"</string>
     <string name="pref_security_show_security_warning" msgid="8901135676266754559">"Mostrar advertencias"</string>
-    <string name="pref_security_show_security_warning_summary" msgid="5260098316025397525">"Mostrar advertencia si se produce una incidencia relacionada con la seguridad del sitio"</string>
+    <string name="pref_security_show_security_warning_summary" msgid="5260098316025397525">"Mostrar advertencia si se produce un problema relacionado con la seguridad del sitio"</string>
     <string name="pref_security_accept_cookies" msgid="3201367661925047989">"Aceptar cookies"</string>
     <string name="pref_security_accept_cookies_summary" msgid="1907951236154433751">"Permitir que los sitios guarden y consulten datos de cookies"</string>
   <string-array name="pref_text_size_choices">
@@ -292,7 +292,7 @@
     <string name="pref_link_prefetch_summary" msgid="6558181497993206817">"Permitir que el navegador cargue páginas web vinculadas en segundo plano"</string>
     <string name="pref_link_prefetch_dialogtitle" msgid="3804646141622839765">"Carga previa de páginas web"</string>
     <string name="browserFrameNetworkErrorLabel" msgid="8102515020625680714">"Error de conexión"</string>
-    <string name="browserFrameFileErrorLabel" msgid="4703792279852977350">"Incidencia relacionada con el archivo"</string>
+    <string name="browserFrameFileErrorLabel" msgid="4703792279852977350">"Problema relacionado con el archivo"</string>
     <string name="browserFrameFormResubmitLabel" msgid="2385512101948178841"></string>
     <string name="browserFrameFormResubmitMessage" msgid="5244059279866705254">"La página que intentas ver contiene datos que ya se han enviado (\"POSTDATA\"). Si vuelves a enviarlos, se repetirá cualquier acción que haya hecho el formulario en la página (por ejemplo, búsquedas o compras online)."</string>
     <string name="loadSuspendedTitle" msgid="6453376579109644551">"Sin conexión"</string>
